
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('react'), require('react-dom'), require('crypto')) :
	typeof define === 'function' && define.amd ? define(['react', 'react-dom', 'crypto'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.React, global.ReactDOM, global.require$$0));
}(this, (function (React, ReactDOM, require$$0) { 'use strict';

	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

	var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
	var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
	var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function createCommonjsModule(fn) {
	  var module = { exports: {} };
		return fn(module, module.exports), module.exports;
	}

	function commonjsRequire (target) {
		throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
	}

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
	var ReactPropTypesSecret_1 = ReactPropTypesSecret;

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	function emptyFunction() {}

	function emptyFunctionWithReset() {}

	emptyFunctionWithReset.resetWarningCache = emptyFunction;

	var factoryWithThrowingShims = function () {
	  function shim(props, propName, componentName, location, propFullName, secret) {
	    if (secret === ReactPropTypesSecret_1) {
	      // It is still safe when called from React.
	      return;
	    }

	    var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
	    err.name = 'Invariant Violation';
	    throw err;
	  }
	  shim.isRequired = shim;

	  function getShim() {
	    return shim;
	  }
	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.

	  var ReactPropTypes = {
	    array: shim,
	    bool: shim,
	    func: shim,
	    number: shim,
	    object: shim,
	    string: shim,
	    symbol: shim,
	    any: shim,
	    arrayOf: getShim,
	    element: shim,
	    elementType: shim,
	    instanceOf: getShim,
	    node: shim,
	    objectOf: getShim,
	    oneOf: getShim,
	    oneOfType: getShim,
	    shape: getShim,
	    exact: getShim,
	    checkPropTypes: emptyFunctionWithReset,
	    resetWarningCache: emptyFunction
	  };
	  ReactPropTypes.PropTypes = ReactPropTypes;
	  return ReactPropTypes;
	};

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	createCommonjsModule(function (module) {
	  {
	    // By explicitly using `prop-types` you are opting into new production behavior.
	    // http://fb.me/prop-types-in-prod
	    module.exports = factoryWithThrowingShims();
	  }
	});

	var ReactReduxContext = /*#__PURE__*/React__default['default'].createContext(null);

	// Default to a dummy "batch" implementation that just runs the callback
	function defaultNoopBatch(callback) {
	  callback();
	}

	var batch = defaultNoopBatch; // Allow injecting another batching function later

	var setBatch = function setBatch(newBatch) {
	  return batch = newBatch;
	}; // Supply a getter just to skip dealing with ESM bindings

	var getBatch = function getBatch() {
	  return batch;
	};

	// well as nesting subscriptions of descendant components, so that we can ensure the
	// ancestor components re-render before descendants

	var nullListeners = {
	  notify: function notify() {}
	};

	function createListenerCollection() {
	  var batch = getBatch();
	  var first = null;
	  var last = null;
	  return {
	    clear: function clear() {
	      first = null;
	      last = null;
	    },
	    notify: function notify() {
	      batch(function () {
	        var listener = first;

	        while (listener) {
	          listener.callback();
	          listener = listener.next;
	        }
	      });
	    },
	    get: function get() {
	      var listeners = [];
	      var listener = first;

	      while (listener) {
	        listeners.push(listener);
	        listener = listener.next;
	      }

	      return listeners;
	    },
	    subscribe: function subscribe(callback) {
	      var isSubscribed = true;
	      var listener = last = {
	        callback: callback,
	        next: null,
	        prev: last
	      };

	      if (listener.prev) {
	        listener.prev.next = listener;
	      } else {
	        first = listener;
	      }

	      return function unsubscribe() {
	        if (!isSubscribed || first === null) return;
	        isSubscribed = false;

	        if (listener.next) {
	          listener.next.prev = listener.prev;
	        } else {
	          last = listener.prev;
	        }

	        if (listener.prev) {
	          listener.prev.next = listener.next;
	        } else {
	          first = listener.next;
	        }
	      };
	    }
	  };
	}

	var Subscription = /*#__PURE__*/function () {
	  function Subscription(store, parentSub) {
	    this.store = store;
	    this.parentSub = parentSub;
	    this.unsubscribe = null;
	    this.listeners = nullListeners;
	    this.handleChangeWrapper = this.handleChangeWrapper.bind(this);
	  }

	  var _proto = Subscription.prototype;

	  _proto.addNestedSub = function addNestedSub(listener) {
	    this.trySubscribe();
	    return this.listeners.subscribe(listener);
	  };

	  _proto.notifyNestedSubs = function notifyNestedSubs() {
	    this.listeners.notify();
	  };

	  _proto.handleChangeWrapper = function handleChangeWrapper() {
	    if (this.onStateChange) {
	      this.onStateChange();
	    }
	  };

	  _proto.isSubscribed = function isSubscribed() {
	    return Boolean(this.unsubscribe);
	  };

	  _proto.trySubscribe = function trySubscribe() {
	    if (!this.unsubscribe) {
	      this.unsubscribe = this.parentSub ? this.parentSub.addNestedSub(this.handleChangeWrapper) : this.store.subscribe(this.handleChangeWrapper);
	      this.listeners = createListenerCollection();
	    }
	  };

	  _proto.tryUnsubscribe = function tryUnsubscribe() {
	    if (this.unsubscribe) {
	      this.unsubscribe();
	      this.unsubscribe = null;
	      this.listeners.clear();
	      this.listeners = nullListeners;
	    }
	  };

	  return Subscription;
	}();

	function Provider(_ref) {
	  var store = _ref.store,
	      context = _ref.context,
	      children = _ref.children;
	  var contextValue = React.useMemo(function () {
	    var subscription = new Subscription(store);
	    subscription.onStateChange = subscription.notifyNestedSubs;
	    return {
	      store: store,
	      subscription: subscription
	    };
	  }, [store]);
	  var previousState = React.useMemo(function () {
	    return store.getState();
	  }, [store]);
	  React.useEffect(function () {
	    var subscription = contextValue.subscription;
	    subscription.trySubscribe();

	    if (previousState !== store.getState()) {
	      subscription.notifyNestedSubs();
	    }

	    return function () {
	      subscription.tryUnsubscribe();
	      subscription.onStateChange = null;
	    };
	  }, [contextValue, previousState]);
	  var Context = context || ReactReduxContext;
	  return /*#__PURE__*/React__default['default'].createElement(Context.Provider, {
	    value: contextValue
	  }, children);
	}

	/** @license React v16.13.1
	 * react-is.production.min.js
	 *
	 * Copyright (c) Facebook, Inc. and its affiliates.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	var b = "function" === typeof Symbol && Symbol.for,
	    c = b ? Symbol.for("react.element") : 60103,
	    d = b ? Symbol.for("react.portal") : 60106,
	    e = b ? Symbol.for("react.fragment") : 60107,
	    f$6 = b ? Symbol.for("react.strict_mode") : 60108,
	    g = b ? Symbol.for("react.profiler") : 60114,
	    h = b ? Symbol.for("react.provider") : 60109,
	    k = b ? Symbol.for("react.context") : 60110,
	    l = b ? Symbol.for("react.async_mode") : 60111,
	    m = b ? Symbol.for("react.concurrent_mode") : 60111,
	    n = b ? Symbol.for("react.forward_ref") : 60112,
	    p = b ? Symbol.for("react.suspense") : 60113,
	    q = b ? Symbol.for("react.suspense_list") : 60120,
	    r = b ? Symbol.for("react.memo") : 60115,
	    t = b ? Symbol.for("react.lazy") : 60116,
	    v = b ? Symbol.for("react.block") : 60121,
	    w = b ? Symbol.for("react.fundamental") : 60117,
	    x = b ? Symbol.for("react.responder") : 60118,
	    y = b ? Symbol.for("react.scope") : 60119;

	function z(a) {
	  if ("object" === typeof a && null !== a) {
	    var u = a.$$typeof;

	    switch (u) {
	      case c:
	        switch (a = a.type, a) {
	          case l:
	          case m:
	          case e:
	          case g:
	          case f$6:
	          case p:
	            return a;

	          default:
	            switch (a = a && a.$$typeof, a) {
	              case k:
	              case n:
	              case t:
	              case r:
	              case h:
	                return a;

	              default:
	                return u;
	            }

	        }

	      case d:
	        return u;
	    }
	  }
	}

	function A(a) {
	  return z(a) === m;
	}

	var AsyncMode = l;
	var ConcurrentMode = m;
	var ContextConsumer = k;
	var ContextProvider = h;
	var Element = c;
	var ForwardRef = n;
	var Fragment = e;
	var Lazy = t;
	var Memo = r;
	var Portal = d;
	var Profiler = g;
	var StrictMode = f$6;
	var Suspense = p;

	var isAsyncMode = function (a) {
	  return A(a) || z(a) === l;
	};

	var isConcurrentMode = A;

	var isContextConsumer = function (a) {
	  return z(a) === k;
	};

	var isContextProvider = function (a) {
	  return z(a) === h;
	};

	var isElement = function (a) {
	  return "object" === typeof a && null !== a && a.$$typeof === c;
	};

	var isForwardRef = function (a) {
	  return z(a) === n;
	};

	var isFragment = function (a) {
	  return z(a) === e;
	};

	var isLazy = function (a) {
	  return z(a) === t;
	};

	var isMemo = function (a) {
	  return z(a) === r;
	};

	var isPortal = function (a) {
	  return z(a) === d;
	};

	var isProfiler = function (a) {
	  return z(a) === g;
	};

	var isStrictMode = function (a) {
	  return z(a) === f$6;
	};

	var isSuspense = function (a) {
	  return z(a) === p;
	};

	var isValidElementType = function (a) {
	  return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f$6 || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
	};

	var typeOf = z;
	var reactIs_production_min = {
	  AsyncMode: AsyncMode,
	  ConcurrentMode: ConcurrentMode,
	  ContextConsumer: ContextConsumer,
	  ContextProvider: ContextProvider,
	  Element: Element,
	  ForwardRef: ForwardRef,
	  Fragment: Fragment,
	  Lazy: Lazy,
	  Memo: Memo,
	  Portal: Portal,
	  Profiler: Profiler,
	  StrictMode: StrictMode,
	  Suspense: Suspense,
	  isAsyncMode: isAsyncMode,
	  isConcurrentMode: isConcurrentMode,
	  isContextConsumer: isContextConsumer,
	  isContextProvider: isContextProvider,
	  isElement: isElement,
	  isForwardRef: isForwardRef,
	  isFragment: isFragment,
	  isLazy: isLazy,
	  isMemo: isMemo,
	  isPortal: isPortal,
	  isProfiler: isProfiler,
	  isStrictMode: isStrictMode,
	  isSuspense: isSuspense,
	  isValidElementType: isValidElementType,
	  typeOf: typeOf
	};

	var reactIs = createCommonjsModule(function (module) {

	  {
	    module.exports = reactIs_production_min;
	  }
	});

	var FORWARD_REF_STATICS = {
	  '$$typeof': true,
	  render: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true
	};
	var MEMO_STATICS = {
	  '$$typeof': true,
	  compare: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true,
	  type: true
	};
	var TYPE_STATICS = {};
	TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
	TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

	// To get around it, we can conditionally useEffect on the server (no-op) and
	// useLayoutEffect in the browser. We need useLayoutEffect to ensure the store
	// subscription callback always has the selector from the latest render commit
	// available, otherwise a store update may happen between render and the effect,
	// which may cause missed updates; we also must ensure the store subscription
	// is created synchronously, otherwise a store update may occur before the
	// subscription is created and an inconsistent state may be observed

	var useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? React.useLayoutEffect : React.useEffect;

	function symbolObservablePonyfill(root) {
	  var result;
	  var Symbol = root.Symbol;

	  if (typeof Symbol === 'function') {
	    if (Symbol.observable) {
	      result = Symbol.observable;
	    } else {
	      result = Symbol('observable');
	      Symbol.observable = result;
	    }
	  } else {
	    result = '@@observable';
	  }

	  return result;
	}

	/* global window */
	var root;

	if (typeof self !== 'undefined') {
	  root = self;
	} else if (typeof window !== 'undefined') {
	  root = window;
	} else if (typeof global !== 'undefined') {
	  root = global;
	} else if (typeof module !== 'undefined') {
	  root = module;
	} else {
	  root = Function('return this')();
	}

	var result = symbolObservablePonyfill(root);

	/**
	 * These are private action types reserved by Redux.
	 * For any unknown actions, you must return the current state.
	 * If the current state is undefined, you must return the initial state.
	 * Do not reference these action types directly in your code.
	 */

	var randomString = function randomString() {
	  return Math.random().toString(36).substring(7).split('').join('.');
	};

	var ActionTypes = {
	  INIT: "@@redux/INIT" + randomString(),
	  REPLACE: "@@redux/REPLACE" + randomString(),
	  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
	    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
	  }
	};
	/**
	 * @param {any} obj The object to inspect.
	 * @returns {boolean} True if the argument appears to be a plain object.
	 */

	function isPlainObject(obj) {
	  if (typeof obj !== 'object' || obj === null) return false;
	  var proto = obj;

	  while (Object.getPrototypeOf(proto) !== null) {
	    proto = Object.getPrototypeOf(proto);
	  }

	  return Object.getPrototypeOf(obj) === proto;
	}
	/**
	 * Creates a Redux store that holds the state tree.
	 * The only way to change the data in the store is to call `dispatch()` on it.
	 *
	 * There should only be a single store in your app. To specify how different
	 * parts of the state tree respond to actions, you may combine several reducers
	 * into a single reducer function by using `combineReducers`.
	 *
	 * @param {Function} reducer A function that returns the next state tree, given
	 * the current state tree and the action to handle.
	 *
	 * @param {any} [preloadedState] The initial state. You may optionally specify it
	 * to hydrate the state from the server in universal apps, or to restore a
	 * previously serialized user session.
	 * If you use `combineReducers` to produce the root reducer function, this must be
	 * an object with the same shape as `combineReducers` keys.
	 *
	 * @param {Function} [enhancer] The store enhancer. You may optionally specify it
	 * to enhance the store with third-party capabilities such as middleware,
	 * time travel, persistence, etc. The only store enhancer that ships with Redux
	 * is `applyMiddleware()`.
	 *
	 * @returns {Store} A Redux store that lets you read the state, dispatch actions
	 * and subscribe to changes.
	 */


	function createStore(reducer, preloadedState, enhancer) {
	  var _ref2;

	  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
	    throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function.');
	  }

	  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
	    enhancer = preloadedState;
	    preloadedState = undefined;
	  }

	  if (typeof enhancer !== 'undefined') {
	    if (typeof enhancer !== 'function') {
	      throw new Error('Expected the enhancer to be a function.');
	    }

	    return enhancer(createStore)(reducer, preloadedState);
	  }

	  if (typeof reducer !== 'function') {
	    throw new Error('Expected the reducer to be a function.');
	  }

	  var currentReducer = reducer;
	  var currentState = preloadedState;
	  var currentListeners = [];
	  var nextListeners = currentListeners;
	  var isDispatching = false;
	  /**
	   * This makes a shallow copy of currentListeners so we can use
	   * nextListeners as a temporary list while dispatching.
	   *
	   * This prevents any bugs around consumers calling
	   * subscribe/unsubscribe in the middle of a dispatch.
	   */

	  function ensureCanMutateNextListeners() {
	    if (nextListeners === currentListeners) {
	      nextListeners = currentListeners.slice();
	    }
	  }
	  /**
	   * Reads the state tree managed by the store.
	   *
	   * @returns {any} The current state tree of your application.
	   */


	  function getState() {
	    if (isDispatching) {
	      throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');
	    }

	    return currentState;
	  }
	  /**
	   * Adds a change listener. It will be called any time an action is dispatched,
	   * and some part of the state tree may potentially have changed. You may then
	   * call `getState()` to read the current state tree inside the callback.
	   *
	   * You may call `dispatch()` from a change listener, with the following
	   * caveats:
	   *
	   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
	   * If you subscribe or unsubscribe while the listeners are being invoked, this
	   * will not have any effect on the `dispatch()` that is currently in progress.
	   * However, the next `dispatch()` call, whether nested or not, will use a more
	   * recent snapshot of the subscription list.
	   *
	   * 2. The listener should not expect to see all state changes, as the state
	   * might have been updated multiple times during a nested `dispatch()` before
	   * the listener is called. It is, however, guaranteed that all subscribers
	   * registered before the `dispatch()` started will be called with the latest
	   * state by the time it exits.
	   *
	   * @param {Function} listener A callback to be invoked on every dispatch.
	   * @returns {Function} A function to remove this change listener.
	   */


	  function subscribe(listener) {
	    if (typeof listener !== 'function') {
	      throw new Error('Expected the listener to be a function.');
	    }

	    if (isDispatching) {
	      throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');
	    }

	    var isSubscribed = true;
	    ensureCanMutateNextListeners();
	    nextListeners.push(listener);
	    return function unsubscribe() {
	      if (!isSubscribed) {
	        return;
	      }

	      if (isDispatching) {
	        throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');
	      }

	      isSubscribed = false;
	      ensureCanMutateNextListeners();
	      var index = nextListeners.indexOf(listener);
	      nextListeners.splice(index, 1);
	      currentListeners = null;
	    };
	  }
	  /**
	   * Dispatches an action. It is the only way to trigger a state change.
	   *
	   * The `reducer` function, used to create the store, will be called with the
	   * current state tree and the given `action`. Its return value will
	   * be considered the **next** state of the tree, and the change listeners
	   * will be notified.
	   *
	   * The base implementation only supports plain object actions. If you want to
	   * dispatch a Promise, an Observable, a thunk, or something else, you need to
	   * wrap your store creating function into the corresponding middleware. For
	   * example, see the documentation for the `redux-thunk` package. Even the
	   * middleware will eventually dispatch plain object actions using this method.
	   *
	   * @param {Object} action A plain object representing “what changed”. It is
	   * a good idea to keep actions serializable so you can record and replay user
	   * sessions, or use the time travelling `redux-devtools`. An action must have
	   * a `type` property which may not be `undefined`. It is a good idea to use
	   * string constants for action types.
	   *
	   * @returns {Object} For convenience, the same action object you dispatched.
	   *
	   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
	   * return something else (for example, a Promise you can await).
	   */


	  function dispatch(action) {
	    if (!isPlainObject(action)) {
	      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
	    }

	    if (typeof action.type === 'undefined') {
	      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
	    }

	    if (isDispatching) {
	      throw new Error('Reducers may not dispatch actions.');
	    }

	    try {
	      isDispatching = true;
	      currentState = currentReducer(currentState, action);
	    } finally {
	      isDispatching = false;
	    }

	    var listeners = currentListeners = nextListeners;

	    for (var i = 0; i < listeners.length; i++) {
	      var listener = listeners[i];
	      listener();
	    }

	    return action;
	  }
	  /**
	   * Replaces the reducer currently used by the store to calculate the state.
	   *
	   * You might need this if your app implements code splitting and you want to
	   * load some of the reducers dynamically. You might also need this if you
	   * implement a hot reloading mechanism for Redux.
	   *
	   * @param {Function} nextReducer The reducer for the store to use instead.
	   * @returns {void}
	   */


	  function replaceReducer(nextReducer) {
	    if (typeof nextReducer !== 'function') {
	      throw new Error('Expected the nextReducer to be a function.');
	    }

	    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
	    // Any reducers that existed in both the new and old rootReducer
	    // will receive the previous state. This effectively populates
	    // the new state tree with any relevant data from the old one.

	    dispatch({
	      type: ActionTypes.REPLACE
	    });
	  }
	  /**
	   * Interoperability point for observable/reactive libraries.
	   * @returns {observable} A minimal observable of state changes.
	   * For more information, see the observable proposal:
	   * https://github.com/tc39/proposal-observable
	   */


	  function observable() {
	    var _ref;

	    var outerSubscribe = subscribe;
	    return _ref = {
	      /**
	       * The minimal observable subscription method.
	       * @param {Object} observer Any object that can be used as an observer.
	       * The observer object should have a `next` method.
	       * @returns {subscription} An object with an `unsubscribe` method that can
	       * be used to unsubscribe the observable from the store, and prevent further
	       * emission of values from the observable.
	       */
	      subscribe: function subscribe(observer) {
	        if (typeof observer !== 'object' || observer === null) {
	          throw new TypeError('Expected the observer to be an object.');
	        }

	        function observeState() {
	          if (observer.next) {
	            observer.next(getState());
	          }
	        }

	        observeState();
	        var unsubscribe = outerSubscribe(observeState);
	        return {
	          unsubscribe: unsubscribe
	        };
	      }
	    }, _ref[result] = function () {
	      return this;
	    }, _ref;
	  } // When a store is created, an "INIT" action is dispatched so that every
	  // reducer returns their initial state. This effectively populates
	  // the initial state tree.


	  dispatch({
	    type: ActionTypes.INIT
	  });
	  return _ref2 = {
	    dispatch: dispatch,
	    subscribe: subscribe,
	    getState: getState,
	    replaceReducer: replaceReducer
	  }, _ref2[result] = observable, _ref2;
	}

	function _defineProperty(obj, key, value) {
	  if (key in obj) {
	    Object.defineProperty(obj, key, {
	      value: value,
	      enumerable: true,
	      configurable: true,
	      writable: true
	    });
	  } else {
	    obj[key] = value;
	  }

	  return obj;
	}

	function ownKeys$1(object, enumerableOnly) {
	  var keys = Object.keys(object);

	  if (Object.getOwnPropertySymbols) {
	    keys.push.apply(keys, Object.getOwnPropertySymbols(object));
	  }

	  if (enumerableOnly) keys = keys.filter(function (sym) {
	    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
	  });
	  return keys;
	}

	function _objectSpread2(target) {
	  for (var i = 1; i < arguments.length; i++) {
	    var source = arguments[i] != null ? arguments[i] : {};

	    if (i % 2) {
	      ownKeys$1(source, true).forEach(function (key) {
	        _defineProperty(target, key, source[key]);
	      });
	    } else if (Object.getOwnPropertyDescriptors) {
	      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
	    } else {
	      ownKeys$1(source).forEach(function (key) {
	        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
	      });
	    }
	  }

	  return target;
	}
	/**
	 * Composes single-argument functions from right to left. The rightmost
	 * function can take multiple arguments as it provides the signature for
	 * the resulting composite function.
	 *
	 * @param {...Function} funcs The functions to compose.
	 * @returns {Function} A function obtained by composing the argument functions
	 * from right to left. For example, compose(f, g, h) is identical to doing
	 * (...args) => f(g(h(...args))).
	 */


	function compose() {
	  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
	    funcs[_key] = arguments[_key];
	  }

	  if (funcs.length === 0) {
	    return function (arg) {
	      return arg;
	    };
	  }

	  if (funcs.length === 1) {
	    return funcs[0];
	  }

	  return funcs.reduce(function (a, b) {
	    return function () {
	      return a(b.apply(void 0, arguments));
	    };
	  });
	}
	/**
	 * Creates a store enhancer that applies middleware to the dispatch method
	 * of the Redux store. This is handy for a variety of tasks, such as expressing
	 * asynchronous actions in a concise manner, or logging every action payload.
	 *
	 * See `redux-thunk` package as an example of the Redux middleware.
	 *
	 * Because middleware is potentially asynchronous, this should be the first
	 * store enhancer in the composition chain.
	 *
	 * Note that each middleware will be given the `dispatch` and `getState` functions
	 * as named arguments.
	 *
	 * @param {...Function} middlewares The middleware chain to be applied.
	 * @returns {Function} A store enhancer applying the middleware.
	 */


	function applyMiddleware() {
	  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
	    middlewares[_key] = arguments[_key];
	  }

	  return function (createStore) {
	    return function () {
	      var store = createStore.apply(void 0, arguments);

	      var _dispatch = function dispatch() {
	        throw new Error('Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.');
	      };

	      var middlewareAPI = {
	        getState: store.getState,
	        dispatch: function dispatch() {
	          return _dispatch.apply(void 0, arguments);
	        }
	      };
	      var chain = middlewares.map(function (middleware) {
	        return middleware(middlewareAPI);
	      });
	      _dispatch = compose.apply(void 0, chain)(store.dispatch);
	      return _objectSpread2({}, store, {
	        dispatch: _dispatch
	      });
	    };
	  };
	}

	/**
	 * A hook to access the value of the `ReactReduxContext`. This is a low-level
	 * hook that you should usually not need to call directly.
	 *
	 * @returns {any} the value of the `ReactReduxContext`
	 *
	 * @example
	 *
	 * import React from 'react'
	 * import { useReduxContext } from 'react-redux'
	 *
	 * export const CounterComponent = ({ value }) => {
	 *   const { store } = useReduxContext()
	 *   return <div>{store.getState()}</div>
	 * }
	 */

	function useReduxContext() {
	  var contextValue = React.useContext(ReactReduxContext);

	  return contextValue;
	}

	/**
	 * Hook factory, which creates a `useStore` hook bound to a given context.
	 *
	 * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
	 * @returns {Function} A `useStore` hook bound to the specified context.
	 */

	function createStoreHook(context) {
	  if (context === void 0) {
	    context = ReactReduxContext;
	  }

	  var useReduxContext$1 = context === ReactReduxContext ? useReduxContext : function () {
	    return React.useContext(context);
	  };
	  return function useStore() {
	    var _useReduxContext = useReduxContext$1(),
	        store = _useReduxContext.store;

	    return store;
	  };
	}
	/**
	 * A hook to access the redux store.
	 *
	 * @returns {any} the redux store
	 *
	 * @example
	 *
	 * import React from 'react'
	 * import { useStore } from 'react-redux'
	 *
	 * export const ExampleComponent = () => {
	 *   const store = useStore()
	 *   return <div>{store.getState()}</div>
	 * }
	 */

	var useStore = /*#__PURE__*/createStoreHook();

	/**
	 * Hook factory, which creates a `useDispatch` hook bound to a given context.
	 *
	 * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
	 * @returns {Function} A `useDispatch` hook bound to the specified context.
	 */

	function createDispatchHook(context) {
	  if (context === void 0) {
	    context = ReactReduxContext;
	  }

	  var useStore$1 = context === ReactReduxContext ? useStore : createStoreHook(context);
	  return function useDispatch() {
	    var store = useStore$1();
	    return store.dispatch;
	  };
	}
	/**
	 * A hook to access the redux `dispatch` function.
	 *
	 * @returns {any|function} redux store's `dispatch` function
	 *
	 * @example
	 *
	 * import React, { useCallback } from 'react'
	 * import { useDispatch } from 'react-redux'
	 *
	 * export const CounterComponent = ({ value }) => {
	 *   const dispatch = useDispatch()
	 *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])
	 *   return (
	 *     <div>
	 *       <span>{value}</span>
	 *       <button onClick={increaseCounter}>Increase counter</button>
	 *     </div>
	 *   )
	 * }
	 */

	var useDispatch = /*#__PURE__*/createDispatchHook();

	var refEquality = function refEquality(a, b) {
	  return a === b;
	};

	function useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub) {
	  var _useReducer = React.useReducer(function (s) {
	    return s + 1;
	  }, 0),
	      forceRender = _useReducer[1];

	  var subscription = React.useMemo(function () {
	    return new Subscription(store, contextSub);
	  }, [store, contextSub]);
	  var latestSubscriptionCallbackError = React.useRef();
	  var latestSelector = React.useRef();
	  var latestStoreState = React.useRef();
	  var latestSelectedState = React.useRef();
	  var storeState = store.getState();
	  var selectedState;

	  try {
	    if (selector !== latestSelector.current || storeState !== latestStoreState.current || latestSubscriptionCallbackError.current) {
	      selectedState = selector(storeState);
	    } else {
	      selectedState = latestSelectedState.current;
	    }
	  } catch (err) {
	    if (latestSubscriptionCallbackError.current) {
	      err.message += "\nThe error may be correlated with this previous error:\n" + latestSubscriptionCallbackError.current.stack + "\n\n";
	    }

	    throw err;
	  }

	  useIsomorphicLayoutEffect(function () {
	    latestSelector.current = selector;
	    latestStoreState.current = storeState;
	    latestSelectedState.current = selectedState;
	    latestSubscriptionCallbackError.current = undefined;
	  });
	  useIsomorphicLayoutEffect(function () {
	    function checkForUpdates() {
	      try {
	        var newSelectedState = latestSelector.current(store.getState());

	        if (equalityFn(newSelectedState, latestSelectedState.current)) {
	          return;
	        }

	        latestSelectedState.current = newSelectedState;
	      } catch (err) {
	        // we ignore all errors here, since when the component
	        // is re-rendered, the selectors are called again, and
	        // will throw again, if neither props nor store state
	        // changed
	        latestSubscriptionCallbackError.current = err;
	      }

	      forceRender();
	    }

	    subscription.onStateChange = checkForUpdates;
	    subscription.trySubscribe();
	    checkForUpdates();
	    return function () {
	      return subscription.tryUnsubscribe();
	    };
	  }, [store, subscription]);
	  return selectedState;
	}
	/**
	 * Hook factory, which creates a `useSelector` hook bound to a given context.
	 *
	 * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
	 * @returns {Function} A `useSelector` hook bound to the specified context.
	 */


	function createSelectorHook(context) {
	  if (context === void 0) {
	    context = ReactReduxContext;
	  }

	  var useReduxContext$1 = context === ReactReduxContext ? useReduxContext : function () {
	    return React.useContext(context);
	  };
	  return function useSelector(selector, equalityFn) {
	    if (equalityFn === void 0) {
	      equalityFn = refEquality;
	    }

	    var _useReduxContext = useReduxContext$1(),
	        store = _useReduxContext.store,
	        contextSub = _useReduxContext.subscription;

	    var selectedState = useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub);
	    React.useDebugValue(selectedState);
	    return selectedState;
	  };
	}
	/**
	 * A hook to access the redux store's state. This hook takes a selector function
	 * as an argument. The selector is called with the store state.
	 *
	 * This hook takes an optional equality comparison function as the second parameter
	 * that allows you to customize the way the selected state is compared to determine
	 * whether the component needs to be re-rendered.
	 *
	 * @param {Function} selector the selector function
	 * @param {Function=} equalityFn the function that will be used to determine equality
	 *
	 * @returns {any} the selected state
	 *
	 * @example
	 *
	 * import React from 'react'
	 * import { useSelector } from 'react-redux'
	 *
	 * export const CounterComponent = () => {
	 *   const counter = useSelector(state => state.counter)
	 *   return <div>{counter}</div>
	 * }
	 */

	var useSelector = /*#__PURE__*/createSelectorHook();

	setBatch(ReactDOM.unstable_batchedUpdates);

	var check = function (it) {
	  return it && it.Math == Math && it;
	}; // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028


	var global$1 =
	/* global globalThis -- safe */
	check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || check(typeof self == 'object' && self) || check(typeof commonjsGlobal == 'object' && commonjsGlobal) || // eslint-disable-next-line no-new-func -- fallback
	function () {
	  return this;
	}() || Function('return this')();

	var fails = function (exec) {
	  try {
	    return !!exec();
	  } catch (error) {
	    return true;
	  }
	};

	var descriptors = !fails(function () {
	  return Object.defineProperty({}, 1, {
	    get: function () {
	      return 7;
	    }
	  })[1] != 7;
	});

	var isObject = function (it) {
	  return typeof it === 'object' ? it !== null : typeof it === 'function';
	};

	var document$3 = global$1.document; // typeof document.createElement is 'object' in old IE

	var EXISTS = isObject(document$3) && isObject(document$3.createElement);

	var documentCreateElement = function (it) {
	  return EXISTS ? document$3.createElement(it) : {};
	};

	var ie8DomDefine = !descriptors && !fails(function () {
	  return Object.defineProperty(documentCreateElement('div'), 'a', {
	    get: function () {
	      return 7;
	    }
	  }).a != 7;
	});

	var anObject = function (it) {
	  if (!isObject(it)) {
	    throw TypeError(String(it) + ' is not an object');
	  }

	  return it;
	};

	// https://tc39.es/ecma262/#sec-toprimitive
	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
	// and the second argument - flag - preferred type is a string

	var toPrimitive = function (input, PREFERRED_STRING) {
	  if (!isObject(input)) return input;
	  var fn, val;
	  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
	  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
	  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
	  throw TypeError("Can't convert object to primitive value");
	};

	var nativeDefineProperty = Object.defineProperty; // `Object.defineProperty` method
	// https://tc39.es/ecma262/#sec-object.defineproperty

	var f$5 = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
	  anObject(O);
	  P = toPrimitive(P, true);
	  anObject(Attributes);
	  if (ie8DomDefine) try {
	    return nativeDefineProperty(O, P, Attributes);
	  } catch (error) {
	    /* empty */
	  }
	  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
	  if ('value' in Attributes) O[P] = Attributes.value;
	  return O;
	};
	var objectDefineProperty = {
	  f: f$5
	};

	var createPropertyDescriptor = function (bitmap, value) {
	  return {
	    enumerable: !(bitmap & 1),
	    configurable: !(bitmap & 2),
	    writable: !(bitmap & 4),
	    value: value
	  };
	};

	var createNonEnumerableProperty = descriptors ? function (object, key, value) {
	  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
	} : function (object, key, value) {
	  object[key] = value;
	  return object;
	};

	var setGlobal = function (key, value) {
	  try {
	    createNonEnumerableProperty(global$1, key, value);
	  } catch (error) {
	    global$1[key] = value;
	  }

	  return value;
	};

	var SHARED = '__core-js_shared__';
	var store$1 = global$1[SHARED] || setGlobal(SHARED, {});
	var sharedStore = store$1;

	var shared = createCommonjsModule(function (module) {
	  (module.exports = function (key, value) {
	    return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
	  })('versions', []).push({
	    version: '3.9.1',
	    mode: 'global',
	    copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
	  });
	});

	var hasOwnProperty$1 = {}.hasOwnProperty;

	var has$1 = function (it, key) {
	  return hasOwnProperty$1.call(it, key);
	};

	var id = 0;
	var postfix = Math.random();

	var uid = function (key) {
	  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
	};

	var toString$1 = {}.toString;

	var classofRaw = function (it) {
	  return toString$1.call(it).slice(8, -1);
	};

	var engineIsNode = classofRaw(global$1.process) == 'process';

	var path = global$1;

	var aFunction$1 = function (variable) {
	  return typeof variable == 'function' ? variable : undefined;
	};

	var getBuiltIn = function (namespace, method) {
	  return arguments.length < 2 ? aFunction$1(path[namespace]) || aFunction$1(global$1[namespace]) : path[namespace] && path[namespace][method] || global$1[namespace] && global$1[namespace][method];
	};

	var engineUserAgent = getBuiltIn('navigator', 'userAgent') || '';

	var process$3 = global$1.process;
	var versions = process$3 && process$3.versions;
	var v8 = versions && versions.v8;
	var match, version;

	if (v8) {
	  match = v8.split('.');
	  version = match[0] + match[1];
	} else if (engineUserAgent) {
	  match = engineUserAgent.match(/Edge\/(\d+)/);

	  if (!match || match[1] >= 74) {
	    match = engineUserAgent.match(/Chrome\/(\d+)/);
	    if (match) version = match[1];
	  }
	}

	var engineV8Version = version && +version;

	var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
	  /* global Symbol -- required for testing */
	  return !Symbol.sham && ( // Chrome 38 Symbol has incorrect toString conversion
	  // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
	  engineIsNode ? engineV8Version === 38 : engineV8Version > 37 && engineV8Version < 41);
	});

	var useSymbolAsUid = nativeSymbol
	/* global Symbol -- safe */
	&& !Symbol.sham && typeof Symbol.iterator == 'symbol';

	var WellKnownSymbolsStore = shared('wks');
	var Symbol$1 = global$1.Symbol;
	var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;

	var wellKnownSymbol = function (name) {
	  if (!has$1(WellKnownSymbolsStore, name) || !(nativeSymbol || typeof WellKnownSymbolsStore[name] == 'string')) {
	    if (nativeSymbol && has$1(Symbol$1, name)) {
	      WellKnownSymbolsStore[name] = Symbol$1[name];
	    } else {
	      WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
	    }
	  }

	  return WellKnownSymbolsStore[name];
	};

	var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
	var test = {};
	test[TO_STRING_TAG$2] = 'z';
	var toStringTagSupport = String(test) === '[object z]';

	var functionToString = Function.toString; // this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper

	if (typeof sharedStore.inspectSource != 'function') {
	  sharedStore.inspectSource = function (it) {
	    return functionToString.call(it);
	  };
	}

	var inspectSource = sharedStore.inspectSource;

	var WeakMap$1 = global$1.WeakMap;
	var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(inspectSource(WeakMap$1));

	var keys$1 = shared('keys');

	var sharedKey = function (key) {
	  return keys$1[key] || (keys$1[key] = uid(key));
	};

	var hiddenKeys$1 = {};

	var WeakMap = global$1.WeakMap;
	var set$1, get, has;

	var enforce = function (it) {
	  return has(it) ? get(it) : set$1(it, {});
	};

	var getterFor = function (TYPE) {
	  return function (it) {
	    var state;

	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
	      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
	    }

	    return state;
	  };
	};

	if (nativeWeakMap) {
	  var store = sharedStore.state || (sharedStore.state = new WeakMap());
	  var wmget = store.get;
	  var wmhas = store.has;
	  var wmset = store.set;

	  set$1 = function (it, metadata) {
	    metadata.facade = it;
	    wmset.call(store, it, metadata);
	    return metadata;
	  };

	  get = function (it) {
	    return wmget.call(store, it) || {};
	  };

	  has = function (it) {
	    return wmhas.call(store, it);
	  };
	} else {
	  var STATE = sharedKey('state');
	  hiddenKeys$1[STATE] = true;

	  set$1 = function (it, metadata) {
	    metadata.facade = it;
	    createNonEnumerableProperty(it, STATE, metadata);
	    return metadata;
	  };

	  get = function (it) {
	    return has$1(it, STATE) ? it[STATE] : {};
	  };

	  has = function (it) {
	    return has$1(it, STATE);
	  };
	}

	var internalState = {
	  set: set$1,
	  get: get,
	  has: has,
	  enforce: enforce,
	  getterFor: getterFor
	};

	var redefine = createCommonjsModule(function (module) {
	  var getInternalState = internalState.get;
	  var enforceInternalState = internalState.enforce;
	  var TEMPLATE = String(String).split('String');
	  (module.exports = function (O, key, value, options) {
	    var unsafe = options ? !!options.unsafe : false;
	    var simple = options ? !!options.enumerable : false;
	    var noTargetGet = options ? !!options.noTargetGet : false;
	    var state;

	    if (typeof value == 'function') {
	      if (typeof key == 'string' && !has$1(value, 'name')) {
	        createNonEnumerableProperty(value, 'name', key);
	      }

	      state = enforceInternalState(value);

	      if (!state.source) {
	        state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
	      }
	    }

	    if (O === global$1) {
	      if (simple) O[key] = value;else setGlobal(key, value);
	      return;
	    } else if (!unsafe) {
	      delete O[key];
	    } else if (!noTargetGet && O[key]) {
	      simple = true;
	    }

	    if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
	  })(Function.prototype, 'toString', function toString() {
	    return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
	  });
	});

	var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag'); // ES3 wrong here

	var CORRECT_ARGUMENTS = classofRaw(function () {
	  return arguments;
	}()) == 'Arguments'; // fallback for IE11 Script Access Denied error

	var tryGet = function (it, key) {
	  try {
	    return it[key];
	  } catch (error) {
	    /* empty */
	  }
	}; // getting tag from ES6+ `Object.prototype.toString`


	var classof = toStringTagSupport ? classofRaw : function (it) {
	  var O, tag, result;
	  return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case
	  : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag // builtinTag case
	  : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback
	  : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
	};

	// https://tc39.es/ecma262/#sec-object.prototype.tostring


	var objectToString = toStringTagSupport ? {}.toString : function toString() {
	  return '[object ' + classof(this) + ']';
	};

	// https://tc39.es/ecma262/#sec-object.prototype.tostring

	if (!toStringTagSupport) {
	  redefine(Object.prototype, 'toString', objectToString, {
	    unsafe: true
	  });
	}

	// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags


	var regexpFlags = function () {
	  var that = anObject(this);
	  var result = '';
	  if (that.global) result += 'g';
	  if (that.ignoreCase) result += 'i';
	  if (that.multiline) result += 'm';
	  if (that.dotAll) result += 's';
	  if (that.unicode) result += 'u';
	  if (that.sticky) result += 'y';
	  return result;
	};

	var TO_STRING = 'toString';
	var RegExpPrototype = RegExp.prototype;
	var nativeToString = RegExpPrototype[TO_STRING];
	var NOT_GENERIC = fails(function () {
	  return nativeToString.call({
	    source: 'a',
	    flags: 'b'
	  }) != '/a/b';
	}); // FF44- RegExp#toString has a wrong name

	var INCORRECT_NAME = nativeToString.name != TO_STRING; // `RegExp.prototype.toString` method
	// https://tc39.es/ecma262/#sec-regexp.prototype.tostring

	if (NOT_GENERIC || INCORRECT_NAME) {
	  redefine(RegExp.prototype, TO_STRING, function toString() {
	    var R = anObject(this);
	    var p = String(R.source);
	    var rf = R.flags;
	    var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? regexpFlags.call(R) : rf);
	    return '/' + p + '/' + f;
	  }, {
	    unsafe: true
	  });
	}

	var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
	var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; // Nashorn ~ JDK8 bug

	var NASHORN_BUG = getOwnPropertyDescriptor$3 && !nativePropertyIsEnumerable.call({
	  1: 2
	}, 1); // `Object.prototype.propertyIsEnumerable` method implementation
	// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable

	var f$4 = NASHORN_BUG ? function propertyIsEnumerable(V) {
	  var descriptor = getOwnPropertyDescriptor$3(this, V);
	  return !!descriptor && descriptor.enumerable;
	} : nativePropertyIsEnumerable;
	var objectPropertyIsEnumerable = {
	  f: f$4
	};

	var split = ''.split; // fallback for non-array-like ES3 and non-enumerable old V8 strings

	var indexedObject = fails(function () {
	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
	  // eslint-disable-next-line no-prototype-builtins -- safe
	  return !Object('z').propertyIsEnumerable(0);
	}) ? function (it) {
	  return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
	} : Object;

	// `RequireObjectCoercible` abstract operation
	// https://tc39.es/ecma262/#sec-requireobjectcoercible
	var requireObjectCoercible = function (it) {
	  if (it == undefined) throw TypeError("Can't call method on " + it);
	  return it;
	};

	var toIndexedObject = function (it) {
	  return indexedObject(requireObjectCoercible(it));
	};

	var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; // `Object.getOwnPropertyDescriptor` method
	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor

	var f$3 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
	  O = toIndexedObject(O);
	  P = toPrimitive(P, true);
	  if (ie8DomDefine) try {
	    return nativeGetOwnPropertyDescriptor(O, P);
	  } catch (error) {
	    /* empty */
	  }
	  if (has$1(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
	};
	var objectGetOwnPropertyDescriptor = {
	  f: f$3
	};

	var ceil = Math.ceil;
	var floor = Math.floor; // `ToInteger` abstract operation
	// https://tc39.es/ecma262/#sec-tointeger

	var toInteger = function (argument) {
	  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
	};

	var min$1 = Math.min; // `ToLength` abstract operation
	// https://tc39.es/ecma262/#sec-tolength

	var toLength = function (argument) {
	  return argument > 0 ? min$1(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
	};

	var max = Math.max;
	var min = Math.min; // Helper for a popular repeating case of the spec:
	// Let integer be ? ToInteger(index).
	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).

	var toAbsoluteIndex = function (index, length) {
	  var integer = toInteger(index);
	  return integer < 0 ? max(integer + length, 0) : min(integer, length);
	};

	var createMethod$3 = function (IS_INCLUDES) {
	  return function ($this, el, fromIndex) {
	    var O = toIndexedObject($this);
	    var length = toLength(O.length);
	    var index = toAbsoluteIndex(fromIndex, length);
	    var value; // Array#includes uses SameValueZero equality algorithm
	    // eslint-disable-next-line no-self-compare -- NaN check

	    if (IS_INCLUDES && el != el) while (length > index) {
	      value = O[index++]; // eslint-disable-next-line no-self-compare -- NaN check

	      if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
	    } else for (; length > index; index++) {
	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
	    }
	    return !IS_INCLUDES && -1;
	  };
	};

	var arrayIncludes = {
	  // `Array.prototype.includes` method
	  // https://tc39.es/ecma262/#sec-array.prototype.includes
	  includes: createMethod$3(true),
	  // `Array.prototype.indexOf` method
	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
	  indexOf: createMethod$3(false)
	};

	var indexOf = arrayIncludes.indexOf;

	var objectKeysInternal = function (object, names) {
	  var O = toIndexedObject(object);
	  var i = 0;
	  var result = [];
	  var key;

	  for (key in O) !has$1(hiddenKeys$1, key) && has$1(O, key) && result.push(key); // Don't enum bug & hidden keys


	  while (names.length > i) if (has$1(O, key = names[i++])) {
	    ~indexOf(result, key) || result.push(key);
	  }

	  return result;
	};

	// IE8- don't enum bug keys
	var enumBugKeys = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];

	var hiddenKeys = enumBugKeys.concat('length', 'prototype'); // `Object.getOwnPropertyNames` method
	// https://tc39.es/ecma262/#sec-object.getownpropertynames

	var f$2 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
	  return objectKeysInternal(O, hiddenKeys);
	};

	var objectGetOwnPropertyNames = {
	  f: f$2
	};

	var f$1 = Object.getOwnPropertySymbols;
	var objectGetOwnPropertySymbols = {
	  f: f$1
	};

	var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
	  var keys = objectGetOwnPropertyNames.f(anObject(it));
	  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
	  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
	};

	var copyConstructorProperties = function (target, source) {
	  var keys = ownKeys(source);
	  var defineProperty = objectDefineProperty.f;
	  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;

	  for (var i = 0; i < keys.length; i++) {
	    var key = keys[i];
	    if (!has$1(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
	  }
	};

	var replacement = /#|\.prototype\./;

	var isForced = function (feature, detection) {
	  var value = data[normalize(feature)];
	  return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;
	};

	var normalize = isForced.normalize = function (string) {
	  return String(string).replace(replacement, '.').toLowerCase();
	};

	var data = isForced.data = {};
	var NATIVE = isForced.NATIVE = 'N';
	var POLYFILL = isForced.POLYFILL = 'P';
	var isForced_1 = isForced;

	var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
	/*
	  options.target      - name of the target object
	  options.global      - target is the global object
	  options.stat        - export as static methods of target
	  options.proto       - export as prototype methods of target
	  options.real        - real prototype method for the `pure` version
	  options.forced      - export even if the native feature is available
	  options.bind        - bind methods to the target, required for the `pure` version
	  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
	  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
	  options.sham        - add a flag to not completely full polyfills
	  options.enumerable  - export as enumerable property
	  options.noTargetGet - prevent calling a getter on target
	*/

	var _export = function (options, source) {
	  var TARGET = options.target;
	  var GLOBAL = options.global;
	  var STATIC = options.stat;
	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;

	  if (GLOBAL) {
	    target = global$1;
	  } else if (STATIC) {
	    target = global$1[TARGET] || setGlobal(TARGET, {});
	  } else {
	    target = (global$1[TARGET] || {}).prototype;
	  }

	  if (target) for (key in source) {
	    sourceProperty = source[key];

	    if (options.noTargetGet) {
	      descriptor = getOwnPropertyDescriptor$2(target, key);
	      targetProperty = descriptor && descriptor.value;
	    } else targetProperty = target[key];

	    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target

	    if (!FORCED && targetProperty !== undefined) {
	      if (typeof sourceProperty === typeof targetProperty) continue;
	      copyConstructorProperties(sourceProperty, targetProperty);
	    } // add a flag to not completely full polyfills


	    if (options.sham || targetProperty && targetProperty.sham) {
	      createNonEnumerableProperty(sourceProperty, 'sham', true);
	    } // extend global


	    redefine(target, key, sourceProperty, options);
	  }
	};

	var nativePromiseConstructor = global$1.Promise;

	var redefineAll = function (target, src, options) {
	  for (var key in src) redefine(target, key, src[key], options);

	  return target;
	};

	var defineProperty$1 = objectDefineProperty.f;
	var TO_STRING_TAG = wellKnownSymbol('toStringTag');

	var setToStringTag = function (it, TAG, STATIC) {
	  if (it && !has$1(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
	    defineProperty$1(it, TO_STRING_TAG, {
	      configurable: true,
	      value: TAG
	    });
	  }
	};

	var SPECIES$4 = wellKnownSymbol('species');

	var setSpecies = function (CONSTRUCTOR_NAME) {
	  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
	  var defineProperty = objectDefineProperty.f;

	  if (descriptors && Constructor && !Constructor[SPECIES$4]) {
	    defineProperty(Constructor, SPECIES$4, {
	      configurable: true,
	      get: function () {
	        return this;
	      }
	    });
	  }
	};

	var aFunction = function (it) {
	  if (typeof it != 'function') {
	    throw TypeError(String(it) + ' is not a function');
	  }

	  return it;
	};

	var anInstance = function (it, Constructor, name) {
	  if (!(it instanceof Constructor)) {
	    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
	  }

	  return it;
	};

	var iterators = {};

	var ITERATOR$2 = wellKnownSymbol('iterator');
	var ArrayPrototype = Array.prototype; // check on default Array iterator

	var isArrayIteratorMethod = function (it) {
	  return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR$2] === it);
	};

	var functionBindContext = function (fn, that, length) {
	  aFunction(fn);
	  if (that === undefined) return fn;

	  switch (length) {
	    case 0:
	      return function () {
	        return fn.call(that);
	      };

	    case 1:
	      return function (a) {
	        return fn.call(that, a);
	      };

	    case 2:
	      return function (a, b) {
	        return fn.call(that, a, b);
	      };

	    case 3:
	      return function (a, b, c) {
	        return fn.call(that, a, b, c);
	      };
	  }

	  return function ()
	  /* ...args */
	  {
	    return fn.apply(that, arguments);
	  };
	};

	var ITERATOR$1 = wellKnownSymbol('iterator');

	var getIteratorMethod = function (it) {
	  if (it != undefined) return it[ITERATOR$1] || it['@@iterator'] || iterators[classof(it)];
	};

	var iteratorClose = function (iterator) {
	  var returnMethod = iterator['return'];

	  if (returnMethod !== undefined) {
	    return anObject(returnMethod.call(iterator)).value;
	  }
	};

	var Result = function (stopped, result) {
	  this.stopped = stopped;
	  this.result = result;
	};

	var iterate = function (iterable, unboundFunction, options) {
	  var that = options && options.that;
	  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
	  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
	  var INTERRUPTED = !!(options && options.INTERRUPTED);
	  var fn = functionBindContext(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED);
	  var iterator, iterFn, index, length, result, next, step;

	  var stop = function (condition) {
	    if (iterator) iteratorClose(iterator);
	    return new Result(true, condition);
	  };

	  var callFn = function (value) {
	    if (AS_ENTRIES) {
	      anObject(value);
	      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
	    }

	    return INTERRUPTED ? fn(value, stop) : fn(value);
	  };

	  if (IS_ITERATOR) {
	    iterator = iterable;
	  } else {
	    iterFn = getIteratorMethod(iterable);
	    if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); // optimisation for array iterators

	    if (isArrayIteratorMethod(iterFn)) {
	      for (index = 0, length = toLength(iterable.length); length > index; index++) {
	        result = callFn(iterable[index]);
	        if (result && result instanceof Result) return result;
	      }

	      return new Result(false);
	    }

	    iterator = iterFn.call(iterable);
	  }

	  next = iterator.next;

	  while (!(step = next.call(iterator)).done) {
	    try {
	      result = callFn(step.value);
	    } catch (error) {
	      iteratorClose(iterator);
	      throw error;
	    }

	    if (typeof result == 'object' && result && result instanceof Result) return result;
	  }

	  return new Result(false);
	};

	var ITERATOR = wellKnownSymbol('iterator');
	var SAFE_CLOSING = false;

	try {
	  var called = 0;
	  var iteratorWithReturn = {
	    next: function () {
	      return {
	        done: !!called++
	      };
	    },
	    'return': function () {
	      SAFE_CLOSING = true;
	    }
	  };

	  iteratorWithReturn[ITERATOR] = function () {
	    return this;
	  }; // eslint-disable-next-line no-throw-literal -- required for testing


	  Array.from(iteratorWithReturn, function () {
	    throw 2;
	  });
	} catch (error) {
	  /* empty */
	}

	var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
	  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
	  var ITERATION_SUPPORT = false;

	  try {
	    var object = {};

	    object[ITERATOR] = function () {
	      return {
	        next: function () {
	          return {
	            done: ITERATION_SUPPORT = true
	          };
	        }
	      };
	    };

	    exec(object);
	  } catch (error) {
	    /* empty */
	  }

	  return ITERATION_SUPPORT;
	};

	var SPECIES$3 = wellKnownSymbol('species'); // `SpeciesConstructor` abstract operation
	// https://tc39.es/ecma262/#sec-speciesconstructor

	var speciesConstructor = function (O, defaultConstructor) {
	  var C = anObject(O).constructor;
	  var S;
	  return C === undefined || (S = anObject(C)[SPECIES$3]) == undefined ? defaultConstructor : aFunction(S);
	};

	var html = getBuiltIn('document', 'documentElement');

	var engineIsIos = /(iphone|ipod|ipad).*applewebkit/i.test(engineUserAgent);

	var location = global$1.location;
	var set = global$1.setImmediate;
	var clear = global$1.clearImmediate;
	var process$2 = global$1.process;
	var MessageChannel = global$1.MessageChannel;
	var Dispatch = global$1.Dispatch;
	var counter$1 = 0;
	var queue = {};
	var ONREADYSTATECHANGE = 'onreadystatechange';
	var defer, channel, port;

	var run = function (id) {
	  // eslint-disable-next-line no-prototype-builtins -- safe
	  if (queue.hasOwnProperty(id)) {
	    var fn = queue[id];
	    delete queue[id];
	    fn();
	  }
	};

	var runner = function (id) {
	  return function () {
	    run(id);
	  };
	};

	var listener = function (event) {
	  run(event.data);
	};

	var post = function (id) {
	  // old engines have not location.origin
	  global$1.postMessage(id + '', location.protocol + '//' + location.host);
	}; // Node.js 0.9+ & IE10+ has setImmediate, otherwise:


	if (!set || !clear) {
	  set = function setImmediate(fn) {
	    var args = [];
	    var i = 1;

	    while (arguments.length > i) args.push(arguments[i++]);

	    queue[++counter$1] = function () {
	      // eslint-disable-next-line no-new-func -- spec requirement
	      (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
	    };

	    defer(counter$1);
	    return counter$1;
	  };

	  clear = function clearImmediate(id) {
	    delete queue[id];
	  }; // Node.js 0.8-


	  if (engineIsNode) {
	    defer = function (id) {
	      process$2.nextTick(runner(id));
	    }; // Sphere (JS game engine) Dispatch API

	  } else if (Dispatch && Dispatch.now) {
	    defer = function (id) {
	      Dispatch.now(runner(id));
	    }; // Browsers with MessageChannel, includes WebWorkers
	    // except iOS - https://github.com/zloirock/core-js/issues/624

	  } else if (MessageChannel && !engineIsIos) {
	    channel = new MessageChannel();
	    port = channel.port2;
	    channel.port1.onmessage = listener;
	    defer = functionBindContext(port.postMessage, port, 1); // Browsers with postMessage, skip WebWorkers
	    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
	  } else if (global$1.addEventListener && typeof postMessage == 'function' && !global$1.importScripts && location && location.protocol !== 'file:' && !fails(post)) {
	    defer = post;
	    global$1.addEventListener('message', listener, false); // IE8-
	  } else if (ONREADYSTATECHANGE in documentCreateElement('script')) {
	    defer = function (id) {
	      html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () {
	        html.removeChild(this);
	        run(id);
	      };
	    }; // Rest old browsers

	  } else {
	    defer = function (id) {
	      setTimeout(runner(id), 0);
	    };
	  }
	}

	var task$1 = {
	  set: set,
	  clear: clear
	};

	var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(engineUserAgent);

	var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
	var macrotask = task$1.set;
	var MutationObserver = global$1.MutationObserver || global$1.WebKitMutationObserver;
	var document$2 = global$1.document;
	var process$1 = global$1.process;
	var Promise$1 = global$1.Promise; // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`

	var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$1, 'queueMicrotask');
	var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
	var flush, head, last, notify$1, toggle, node, promise, then; // modern engines have queueMicrotask method

	if (!queueMicrotask) {
	  flush = function () {
	    var parent, fn;
	    if (engineIsNode && (parent = process$1.domain)) parent.exit();

	    while (head) {
	      fn = head.fn;
	      head = head.next;

	      try {
	        fn();
	      } catch (error) {
	        if (head) notify$1();else last = undefined;
	        throw error;
	      }
	    }

	    last = undefined;
	    if (parent) parent.enter();
	  }; // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
	  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898


	  if (!engineIsIos && !engineIsNode && !engineIsWebosWebkit && MutationObserver && document$2) {
	    toggle = true;
	    node = document$2.createTextNode('');
	    new MutationObserver(flush).observe(node, {
	      characterData: true
	    });

	    notify$1 = function () {
	      node.data = toggle = !toggle;
	    }; // environments with maybe non-completely correct, but existent Promise

	  } else if (Promise$1 && Promise$1.resolve) {
	    // Promise.resolve without an argument throws an error in LG WebOS 2
	    promise = Promise$1.resolve(undefined);
	    then = promise.then;

	    notify$1 = function () {
	      then.call(promise, flush);
	    }; // Node.js without promises

	  } else if (engineIsNode) {
	    notify$1 = function () {
	      process$1.nextTick(flush);
	    }; // for other environments - macrotask based on:
	    // - setImmediate
	    // - MessageChannel
	    // - window.postMessag
	    // - onreadystatechange
	    // - setTimeout

	  } else {
	    notify$1 = function () {
	      // strange IE + webpack dev server bug - use .call(global)
	      macrotask.call(global$1, flush);
	    };
	  }
	}

	var microtask = queueMicrotask || function (fn) {
	  var task = {
	    fn: fn,
	    next: undefined
	  };
	  if (last) last.next = task;

	  if (!head) {
	    head = task;
	    notify$1();
	  }

	  last = task;
	};

	var PromiseCapability = function (C) {
	  var resolve, reject;
	  this.promise = new C(function ($$resolve, $$reject) {
	    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
	    resolve = $$resolve;
	    reject = $$reject;
	  });
	  this.resolve = aFunction(resolve);
	  this.reject = aFunction(reject);
	}; // 25.4.1.5 NewPromiseCapability(C)


	var f = function (C) {
	  return new PromiseCapability(C);
	};

	var newPromiseCapability$1 = {
	  f: f
	};

	var promiseResolve = function (C, x) {
	  anObject(C);
	  if (isObject(x) && x.constructor === C) return x;
	  var promiseCapability = newPromiseCapability$1.f(C);
	  var resolve = promiseCapability.resolve;
	  resolve(x);
	  return promiseCapability.promise;
	};

	var hostReportErrors = function (a, b) {
	  var console = global$1.console;

	  if (console && console.error) {
	    arguments.length === 1 ? console.error(a) : console.error(a, b);
	  }
	};

	var perform = function (exec) {
	  try {
	    return {
	      error: false,
	      value: exec()
	    };
	  } catch (error) {
	    return {
	      error: true,
	      value: error
	    };
	  }
	};

	var task = task$1.set;
	var SPECIES$2 = wellKnownSymbol('species');
	var PROMISE = 'Promise';
	var getInternalState = internalState.get;
	var setInternalState = internalState.set;
	var getInternalPromiseState = internalState.getterFor(PROMISE);
	var PromiseConstructor = nativePromiseConstructor;
	var TypeError$1 = global$1.TypeError;
	var document$1 = global$1.document;
	var process = global$1.process;
	var $fetch = getBuiltIn('fetch');
	var newPromiseCapability = newPromiseCapability$1.f;
	var newGenericPromiseCapability = newPromiseCapability;
	var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$1.dispatchEvent);
	var NATIVE_REJECTION_EVENT = typeof PromiseRejectionEvent == 'function';
	var UNHANDLED_REJECTION = 'unhandledrejection';
	var REJECTION_HANDLED = 'rejectionhandled';
	var PENDING = 0;
	var FULFILLED = 1;
	var REJECTED = 2;
	var HANDLED = 1;
	var UNHANDLED = 2;
	var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
	var FORCED = isForced_1(PROMISE, function () {
	  var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);

	  if (!GLOBAL_CORE_JS_PROMISE) {
	    // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
	    // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
	    // We can't detect it synchronously, so just check versions
	    if (engineV8Version === 66) return true; // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test

	    if (!engineIsNode && !NATIVE_REJECTION_EVENT) return true;
	  } // We need Promise#finally in the pure version for preventing prototype pollution
	  // deoptimization and performance degradation
	  // https://github.com/zloirock/core-js/issues/679

	  if (engineV8Version >= 51 && /native code/.test(PromiseConstructor)) return false; // Detect correctness of subclassing with @@species support

	  var promise = PromiseConstructor.resolve(1);

	  var FakePromise = function (exec) {
	    exec(function () {
	      /* empty */
	    }, function () {
	      /* empty */
	    });
	  };

	  var constructor = promise.constructor = {};
	  constructor[SPECIES$2] = FakePromise;
	  return !(promise.then(function () {
	    /* empty */
	  }) instanceof FakePromise);
	});
	var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
	  PromiseConstructor.all(iterable)['catch'](function () {
	    /* empty */
	  });
	}); // helpers

	var isThenable = function (it) {
	  var then;
	  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
	};

	var notify = function (state, isReject) {
	  if (state.notified) return;
	  state.notified = true;
	  var chain = state.reactions;
	  microtask(function () {
	    var value = state.value;
	    var ok = state.state == FULFILLED;
	    var index = 0; // variable length - can't use forEach

	    while (chain.length > index) {
	      var reaction = chain[index++];
	      var handler = ok ? reaction.ok : reaction.fail;
	      var resolve = reaction.resolve;
	      var reject = reaction.reject;
	      var domain = reaction.domain;
	      var result, then, exited;

	      try {
	        if (handler) {
	          if (!ok) {
	            if (state.rejection === UNHANDLED) onHandleUnhandled(state);
	            state.rejection = HANDLED;
	          }

	          if (handler === true) result = value;else {
	            if (domain) domain.enter();
	            result = handler(value); // can throw

	            if (domain) {
	              domain.exit();
	              exited = true;
	            }
	          }

	          if (result === reaction.promise) {
	            reject(TypeError$1('Promise-chain cycle'));
	          } else if (then = isThenable(result)) {
	            then.call(result, resolve, reject);
	          } else resolve(result);
	        } else reject(value);
	      } catch (error) {
	        if (domain && !exited) domain.exit();
	        reject(error);
	      }
	    }

	    state.reactions = [];
	    state.notified = false;
	    if (isReject && !state.rejection) onUnhandled(state);
	  });
	};

	var dispatchEvent = function (name, promise, reason) {
	  var event, handler;

	  if (DISPATCH_EVENT) {
	    event = document$1.createEvent('Event');
	    event.promise = promise;
	    event.reason = reason;
	    event.initEvent(name, false, true);
	    global$1.dispatchEvent(event);
	  } else event = {
	    promise: promise,
	    reason: reason
	  };

	  if (!NATIVE_REJECTION_EVENT && (handler = global$1['on' + name])) handler(event);else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
	};

	var onUnhandled = function (state) {
	  task.call(global$1, function () {
	    var promise = state.facade;
	    var value = state.value;
	    var IS_UNHANDLED = isUnhandled(state);
	    var result;

	    if (IS_UNHANDLED) {
	      result = perform(function () {
	        if (engineIsNode) {
	          process.emit('unhandledRejection', value, promise);
	        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
	      }); // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

	      state.rejection = engineIsNode || isUnhandled(state) ? UNHANDLED : HANDLED;
	      if (result.error) throw result.value;
	    }
	  });
	};

	var isUnhandled = function (state) {
	  return state.rejection !== HANDLED && !state.parent;
	};

	var onHandleUnhandled = function (state) {
	  task.call(global$1, function () {
	    var promise = state.facade;

	    if (engineIsNode) {
	      process.emit('rejectionHandled', promise);
	    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
	  });
	};

	var bind = function (fn, state, unwrap) {
	  return function (value) {
	    fn(state, value, unwrap);
	  };
	};

	var internalReject = function (state, value, unwrap) {
	  if (state.done) return;
	  state.done = true;
	  if (unwrap) state = unwrap;
	  state.value = value;
	  state.state = REJECTED;
	  notify(state, true);
	};

	var internalResolve = function (state, value, unwrap) {
	  if (state.done) return;
	  state.done = true;
	  if (unwrap) state = unwrap;

	  try {
	    if (state.facade === value) throw TypeError$1("Promise can't be resolved itself");
	    var then = isThenable(value);

	    if (then) {
	      microtask(function () {
	        var wrapper = {
	          done: false
	        };

	        try {
	          then.call(value, bind(internalResolve, wrapper, state), bind(internalReject, wrapper, state));
	        } catch (error) {
	          internalReject(wrapper, error, state);
	        }
	      });
	    } else {
	      state.value = value;
	      state.state = FULFILLED;
	      notify(state, false);
	    }
	  } catch (error) {
	    internalReject({
	      done: false
	    }, error, state);
	  }
	}; // constructor polyfill


	if (FORCED) {
	  // 25.4.3.1 Promise(executor)
	  PromiseConstructor = function Promise(executor) {
	    anInstance(this, PromiseConstructor, PROMISE);
	    aFunction(executor);
	    Internal.call(this);
	    var state = getInternalState(this);

	    try {
	      executor(bind(internalResolve, state), bind(internalReject, state));
	    } catch (error) {
	      internalReject(state, error);
	    }
	  }; // eslint-disable-next-line no-unused-vars -- required for `.length`


	  Internal = function Promise(executor) {
	    setInternalState(this, {
	      type: PROMISE,
	      done: false,
	      notified: false,
	      parent: false,
	      reactions: [],
	      rejection: false,
	      state: PENDING,
	      value: undefined
	    });
	  };

	  Internal.prototype = redefineAll(PromiseConstructor.prototype, {
	    // `Promise.prototype.then` method
	    // https://tc39.es/ecma262/#sec-promise.prototype.then
	    then: function then(onFulfilled, onRejected) {
	      var state = getInternalPromiseState(this);
	      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
	      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
	      reaction.fail = typeof onRejected == 'function' && onRejected;
	      reaction.domain = engineIsNode ? process.domain : undefined;
	      state.parent = true;
	      state.reactions.push(reaction);
	      if (state.state != PENDING) notify(state, false);
	      return reaction.promise;
	    },
	    // `Promise.prototype.catch` method
	    // https://tc39.es/ecma262/#sec-promise.prototype.catch
	    'catch': function (onRejected) {
	      return this.then(undefined, onRejected);
	    }
	  });

	  OwnPromiseCapability = function () {
	    var promise = new Internal();
	    var state = getInternalState(promise);
	    this.promise = promise;
	    this.resolve = bind(internalResolve, state);
	    this.reject = bind(internalReject, state);
	  };

	  newPromiseCapability$1.f = newPromiseCapability = function (C) {
	    return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
	  };

	  if (typeof nativePromiseConstructor == 'function') {
	    nativeThen = nativePromiseConstructor.prototype.then; // wrap native Promise#then for native async functions

	    redefine(nativePromiseConstructor.prototype, 'then', function then(onFulfilled, onRejected) {
	      var that = this;
	      return new PromiseConstructor(function (resolve, reject) {
	        nativeThen.call(that, resolve, reject);
	      }).then(onFulfilled, onRejected); // https://github.com/zloirock/core-js/issues/640
	    }, {
	      unsafe: true
	    }); // wrap fetch result

	    if (typeof $fetch == 'function') _export({
	      global: true,
	      enumerable: true,
	      forced: true
	    }, {
	      // eslint-disable-next-line no-unused-vars -- required for `.length`
	      fetch: function fetch(input
	      /* , init */
	      ) {
	        return promiseResolve(PromiseConstructor, $fetch.apply(global$1, arguments));
	      }
	    });
	  }
	}

	_export({
	  global: true,
	  wrap: true,
	  forced: FORCED
	}, {
	  Promise: PromiseConstructor
	});
	setToStringTag(PromiseConstructor, PROMISE, false);
	setSpecies(PROMISE);
	PromiseWrapper = getBuiltIn(PROMISE); // statics

	_export({
	  target: PROMISE,
	  stat: true,
	  forced: FORCED
	}, {
	  // `Promise.reject` method
	  // https://tc39.es/ecma262/#sec-promise.reject
	  reject: function reject(r) {
	    var capability = newPromiseCapability(this);
	    capability.reject.call(undefined, r);
	    return capability.promise;
	  }
	});
	_export({
	  target: PROMISE,
	  stat: true,
	  forced: FORCED
	}, {
	  // `Promise.resolve` method
	  // https://tc39.es/ecma262/#sec-promise.resolve
	  resolve: function resolve(x) {
	    return promiseResolve(this, x);
	  }
	});
	_export({
	  target: PROMISE,
	  stat: true,
	  forced: INCORRECT_ITERATION
	}, {
	  // `Promise.all` method
	  // https://tc39.es/ecma262/#sec-promise.all
	  all: function all(iterable) {
	    var C = this;
	    var capability = newPromiseCapability(C);
	    var resolve = capability.resolve;
	    var reject = capability.reject;
	    var result = perform(function () {
	      var $promiseResolve = aFunction(C.resolve);
	      var values = [];
	      var counter = 0;
	      var remaining = 1;
	      iterate(iterable, function (promise) {
	        var index = counter++;
	        var alreadyCalled = false;
	        values.push(undefined);
	        remaining++;
	        $promiseResolve.call(C, promise).then(function (value) {
	          if (alreadyCalled) return;
	          alreadyCalled = true;
	          values[index] = value;
	          --remaining || resolve(values);
	        }, reject);
	      });
	      --remaining || resolve(values);
	    });
	    if (result.error) reject(result.value);
	    return capability.promise;
	  },
	  // `Promise.race` method
	  // https://tc39.es/ecma262/#sec-promise.race
	  race: function race(iterable) {
	    var C = this;
	    var capability = newPromiseCapability(C);
	    var reject = capability.reject;
	    var result = perform(function () {
	      var $promiseResolve = aFunction(C.resolve);
	      iterate(iterable, function (promise) {
	        $promiseResolve.call(C, promise).then(capability.resolve, reject);
	      });
	    });
	    if (result.error) reject(result.value);
	    return capability.promise;
	  }
	});

	var core = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory();
	    }
	  })(commonjsGlobal, function () {
	    /*globals window, global, require*/

	    /**
	     * CryptoJS core components.
	     */
	    var CryptoJS = CryptoJS || function (Math, undefined$1) {
	      var crypto; // Native crypto from window (Browser)

	      if (typeof window !== 'undefined' && window.crypto) {
	        crypto = window.crypto;
	      } // Native (experimental IE 11) crypto from window (Browser)


	      if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
	        crypto = window.msCrypto;
	      } // Native crypto from global (NodeJS)


	      if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
	        crypto = commonjsGlobal.crypto;
	      } // Native crypto import via require (NodeJS)


	      if (!crypto && typeof commonjsRequire === 'function') {
	        try {
	          crypto = require$$0__default['default'];
	        } catch (err) {}
	      }
	      /*
	       * Cryptographically secure pseudorandom number generator
	       *
	       * As Math.random() is cryptographically not safe to use
	       */


	      var cryptoSecureRandomInt = function () {
	        if (crypto) {
	          // Use getRandomValues method (Browser)
	          if (typeof crypto.getRandomValues === 'function') {
	            try {
	              return crypto.getRandomValues(new Uint32Array(1))[0];
	            } catch (err) {}
	          } // Use randomBytes method (NodeJS)


	          if (typeof crypto.randomBytes === 'function') {
	            try {
	              return crypto.randomBytes(4).readInt32LE();
	            } catch (err) {}
	          }
	        }

	        throw new Error('Native crypto module could not be used to get secure random number.');
	      };
	      /*
	       * Local polyfill of Object.create
	        */


	      var create = Object.create || function () {
	        function F() {}

	        return function (obj) {
	          var subtype;
	          F.prototype = obj;
	          subtype = new F();
	          F.prototype = null;
	          return subtype;
	        };
	      }();
	      /**
	       * CryptoJS namespace.
	       */


	      var C = {};
	      /**
	       * Library namespace.
	       */

	      var C_lib = C.lib = {};
	      /**
	       * Base object for prototypal inheritance.
	       */

	      var Base = C_lib.Base = function () {
	        return {
	          /**
	           * Creates a new object that inherits from this object.
	           *
	           * @param {Object} overrides Properties to copy into the new object.
	           *
	           * @return {Object} The new object.
	           *
	           * @static
	           *
	           * @example
	           *
	           *     var MyType = CryptoJS.lib.Base.extend({
	           *         field: 'value',
	           *
	           *         method: function () {
	           *         }
	           *     });
	           */
	          extend: function (overrides) {
	            // Spawn
	            var subtype = create(this); // Augment

	            if (overrides) {
	              subtype.mixIn(overrides);
	            } // Create default initializer


	            if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
	              subtype.init = function () {
	                subtype.$super.init.apply(this, arguments);
	              };
	            } // Initializer's prototype is the subtype object


	            subtype.init.prototype = subtype; // Reference supertype

	            subtype.$super = this;
	            return subtype;
	          },

	          /**
	           * Extends this object and runs the init method.
	           * Arguments to create() will be passed to init().
	           *
	           * @return {Object} The new object.
	           *
	           * @static
	           *
	           * @example
	           *
	           *     var instance = MyType.create();
	           */
	          create: function () {
	            var instance = this.extend();
	            instance.init.apply(instance, arguments);
	            return instance;
	          },

	          /**
	           * Initializes a newly created object.
	           * Override this method to add some logic when your objects are created.
	           *
	           * @example
	           *
	           *     var MyType = CryptoJS.lib.Base.extend({
	           *         init: function () {
	           *             // ...
	           *         }
	           *     });
	           */
	          init: function () {},

	          /**
	           * Copies properties into this object.
	           *
	           * @param {Object} properties The properties to mix in.
	           *
	           * @example
	           *
	           *     MyType.mixIn({
	           *         field: 'value'
	           *     });
	           */
	          mixIn: function (properties) {
	            for (var propertyName in properties) {
	              if (properties.hasOwnProperty(propertyName)) {
	                this[propertyName] = properties[propertyName];
	              }
	            } // IE won't copy toString using the loop above


	            if (properties.hasOwnProperty('toString')) {
	              this.toString = properties.toString;
	            }
	          },

	          /**
	           * Creates a copy of this object.
	           *
	           * @return {Object} The clone.
	           *
	           * @example
	           *
	           *     var clone = instance.clone();
	           */
	          clone: function () {
	            return this.init.prototype.extend(this);
	          }
	        };
	      }();
	      /**
	       * An array of 32-bit words.
	       *
	       * @property {Array} words The array of 32-bit words.
	       * @property {number} sigBytes The number of significant bytes in this word array.
	       */


	      var WordArray = C_lib.WordArray = Base.extend({
	        /**
	         * Initializes a newly created word array.
	         *
	         * @param {Array} words (Optional) An array of 32-bit words.
	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.create();
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
	         */
	        init: function (words, sigBytes) {
	          words = this.words = words || [];

	          if (sigBytes != undefined$1) {
	            this.sigBytes = sigBytes;
	          } else {
	            this.sigBytes = words.length * 4;
	          }
	        },

	        /**
	         * Converts this word array to a string.
	         *
	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
	         *
	         * @return {string} The stringified word array.
	         *
	         * @example
	         *
	         *     var string = wordArray + '';
	         *     var string = wordArray.toString();
	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
	         */
	        toString: function (encoder) {
	          return (encoder || Hex).stringify(this);
	        },

	        /**
	         * Concatenates a word array to this word array.
	         *
	         * @param {WordArray} wordArray The word array to append.
	         *
	         * @return {WordArray} This word array.
	         *
	         * @example
	         *
	         *     wordArray1.concat(wordArray2);
	         */
	        concat: function (wordArray) {
	          // Shortcuts
	          var thisWords = this.words;
	          var thatWords = wordArray.words;
	          var thisSigBytes = this.sigBytes;
	          var thatSigBytes = wordArray.sigBytes; // Clamp excess bits

	          this.clamp(); // Concat

	          if (thisSigBytes % 4) {
	            // Copy one byte at a time
	            for (var i = 0; i < thatSigBytes; i++) {
	              var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
	              thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
	            }
	          } else {
	            // Copy one word at a time
	            for (var i = 0; i < thatSigBytes; i += 4) {
	              thisWords[thisSigBytes + i >>> 2] = thatWords[i >>> 2];
	            }
	          }

	          this.sigBytes += thatSigBytes; // Chainable

	          return this;
	        },

	        /**
	         * Removes insignificant bits.
	         *
	         * @example
	         *
	         *     wordArray.clamp();
	         */
	        clamp: function () {
	          // Shortcuts
	          var words = this.words;
	          var sigBytes = this.sigBytes; // Clamp

	          words[sigBytes >>> 2] &= 0xffffffff << 32 - sigBytes % 4 * 8;
	          words.length = Math.ceil(sigBytes / 4);
	        },

	        /**
	         * Creates a copy of this word array.
	         *
	         * @return {WordArray} The clone.
	         *
	         * @example
	         *
	         *     var clone = wordArray.clone();
	         */
	        clone: function () {
	          var clone = Base.clone.call(this);
	          clone.words = this.words.slice(0);
	          return clone;
	        },

	        /**
	         * Creates a word array filled with random bytes.
	         *
	         * @param {number} nBytes The number of random bytes to generate.
	         *
	         * @return {WordArray} The random word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
	         */
	        random: function (nBytes) {
	          var words = [];

	          for (var i = 0; i < nBytes; i += 4) {
	            words.push(cryptoSecureRandomInt());
	          }

	          return new WordArray.init(words, nBytes);
	        }
	      });
	      /**
	       * Encoder namespace.
	       */

	      var C_enc = C.enc = {};
	      /**
	       * Hex encoding strategy.
	       */

	      var Hex = C_enc.Hex = {
	        /**
	         * Converts a word array to a hex string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The hex string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	          // Shortcuts
	          var words = wordArray.words;
	          var sigBytes = wordArray.sigBytes; // Convert

	          var hexChars = [];

	          for (var i = 0; i < sigBytes; i++) {
	            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
	            hexChars.push((bite >>> 4).toString(16));
	            hexChars.push((bite & 0x0f).toString(16));
	          }

	          return hexChars.join('');
	        },

	        /**
	         * Converts a hex string to a word array.
	         *
	         * @param {string} hexStr The hex string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
	         */
	        parse: function (hexStr) {
	          // Shortcut
	          var hexStrLength = hexStr.length; // Convert

	          var words = [];

	          for (var i = 0; i < hexStrLength; i += 2) {
	            words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
	          }

	          return new WordArray.init(words, hexStrLength / 2);
	        }
	      };
	      /**
	       * Latin1 encoding strategy.
	       */

	      var Latin1 = C_enc.Latin1 = {
	        /**
	         * Converts a word array to a Latin1 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The Latin1 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	          // Shortcuts
	          var words = wordArray.words;
	          var sigBytes = wordArray.sigBytes; // Convert

	          var latin1Chars = [];

	          for (var i = 0; i < sigBytes; i++) {
	            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
	            latin1Chars.push(String.fromCharCode(bite));
	          }

	          return latin1Chars.join('');
	        },

	        /**
	         * Converts a Latin1 string to a word array.
	         *
	         * @param {string} latin1Str The Latin1 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
	         */
	        parse: function (latin1Str) {
	          // Shortcut
	          var latin1StrLength = latin1Str.length; // Convert

	          var words = [];

	          for (var i = 0; i < latin1StrLength; i++) {
	            words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << 24 - i % 4 * 8;
	          }

	          return new WordArray.init(words, latin1StrLength);
	        }
	      };
	      /**
	       * UTF-8 encoding strategy.
	       */

	      var Utf8 = C_enc.Utf8 = {
	        /**
	         * Converts a word array to a UTF-8 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The UTF-8 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	          try {
	            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
	          } catch (e) {
	            throw new Error('Malformed UTF-8 data');
	          }
	        },

	        /**
	         * Converts a UTF-8 string to a word array.
	         *
	         * @param {string} utf8Str The UTF-8 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
	         */
	        parse: function (utf8Str) {
	          return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
	        }
	      };
	      /**
	       * Abstract buffered block algorithm template.
	       *
	       * The property blockSize must be implemented in a concrete subtype.
	       *
	       * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
	       */

	      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
	        /**
	         * Resets this block algorithm's data buffer to its initial state.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm.reset();
	         */
	        reset: function () {
	          // Initial values
	          this._data = new WordArray.init();
	          this._nDataBytes = 0;
	        },

	        /**
	         * Adds new data to this block algorithm's buffer.
	         *
	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm._append('data');
	         *     bufferedBlockAlgorithm._append(wordArray);
	         */
	        _append: function (data) {
	          // Convert string to WordArray, else assume WordArray already
	          if (typeof data == 'string') {
	            data = Utf8.parse(data);
	          } // Append


	          this._data.concat(data);

	          this._nDataBytes += data.sigBytes;
	        },

	        /**
	         * Processes available data blocks.
	         *
	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
	         *
	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
	         *
	         * @return {WordArray} The processed data.
	         *
	         * @example
	         *
	         *     var processedData = bufferedBlockAlgorithm._process();
	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
	         */
	        _process: function (doFlush) {
	          var processedWords; // Shortcuts

	          var data = this._data;
	          var dataWords = data.words;
	          var dataSigBytes = data.sigBytes;
	          var blockSize = this.blockSize;
	          var blockSizeBytes = blockSize * 4; // Count blocks ready

	          var nBlocksReady = dataSigBytes / blockSizeBytes;

	          if (doFlush) {
	            // Round up to include partial blocks
	            nBlocksReady = Math.ceil(nBlocksReady);
	          } else {
	            // Round down to include only full blocks,
	            // less the number of blocks that must remain in the buffer
	            nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
	          } // Count words ready


	          var nWordsReady = nBlocksReady * blockSize; // Count bytes ready

	          var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); // Process blocks

	          if (nWordsReady) {
	            for (var offset = 0; offset < nWordsReady; offset += blockSize) {
	              // Perform concrete-algorithm logic
	              this._doProcessBlock(dataWords, offset);
	            } // Remove processed words


	            processedWords = dataWords.splice(0, nWordsReady);
	            data.sigBytes -= nBytesReady;
	          } // Return processed words


	          return new WordArray.init(processedWords, nBytesReady);
	        },

	        /**
	         * Creates a copy of this object.
	         *
	         * @return {Object} The clone.
	         *
	         * @example
	         *
	         *     var clone = bufferedBlockAlgorithm.clone();
	         */
	        clone: function () {
	          var clone = Base.clone.call(this);
	          clone._data = this._data.clone();
	          return clone;
	        },
	        _minBufferSize: 0
	      });
	      /**
	       * Abstract hasher template.
	       *
	       * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
	       */

	      C_lib.Hasher = BufferedBlockAlgorithm.extend({
	        /**
	         * Configuration options.
	         */
	        cfg: Base.extend(),

	        /**
	         * Initializes a newly created hasher.
	         *
	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
	         *
	         * @example
	         *
	         *     var hasher = CryptoJS.algo.SHA256.create();
	         */
	        init: function (cfg) {
	          // Apply config defaults
	          this.cfg = this.cfg.extend(cfg); // Set initial values

	          this.reset();
	        },

	        /**
	         * Resets this hasher to its initial state.
	         *
	         * @example
	         *
	         *     hasher.reset();
	         */
	        reset: function () {
	          // Reset data buffer
	          BufferedBlockAlgorithm.reset.call(this); // Perform concrete-hasher logic

	          this._doReset();
	        },

	        /**
	         * Updates this hasher with a message.
	         *
	         * @param {WordArray|string} messageUpdate The message to append.
	         *
	         * @return {Hasher} This hasher.
	         *
	         * @example
	         *
	         *     hasher.update('message');
	         *     hasher.update(wordArray);
	         */
	        update: function (messageUpdate) {
	          // Append
	          this._append(messageUpdate); // Update the hash


	          this._process(); // Chainable


	          return this;
	        },

	        /**
	         * Finalizes the hash computation.
	         * Note that the finalize operation is effectively a destructive, read-once operation.
	         *
	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
	         *
	         * @return {WordArray} The hash.
	         *
	         * @example
	         *
	         *     var hash = hasher.finalize();
	         *     var hash = hasher.finalize('message');
	         *     var hash = hasher.finalize(wordArray);
	         */
	        finalize: function (messageUpdate) {
	          // Final message update
	          if (messageUpdate) {
	            this._append(messageUpdate);
	          } // Perform concrete-hasher logic


	          var hash = this._doFinalize();

	          return hash;
	        },
	        blockSize: 512 / 32,

	        /**
	         * Creates a shortcut function to a hasher's object interface.
	         *
	         * @param {Hasher} hasher The hasher to create a helper for.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
	         */
	        _createHelper: function (hasher) {
	          return function (message, cfg) {
	            return new hasher.init(cfg).finalize(message);
	          };
	        },

	        /**
	         * Creates a shortcut function to the HMAC's object interface.
	         *
	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
	         */
	        _createHmacHelper: function (hasher) {
	          return function (message, key) {
	            return new C_algo.HMAC.init(hasher, key).finalize(message);
	          };
	        }
	      });
	      /**
	       * Algorithm namespace.
	       */

	      var C_algo = C.algo = {};
	      return C;
	    }(Math);

	    return CryptoJS;
	  });
	});

	var encBase64 = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory(core);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function () {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var WordArray = C_lib.WordArray;
	      var C_enc = C.enc;
	      /**
	       * Base64 encoding strategy.
	       */

	      C_enc.Base64 = {
	        /**
	         * Converts a word array to a Base64 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The Base64 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	          // Shortcuts
	          var words = wordArray.words;
	          var sigBytes = wordArray.sigBytes;
	          var map = this._map; // Clamp excess bits

	          wordArray.clamp(); // Convert

	          var base64Chars = [];

	          for (var i = 0; i < sigBytes; i += 3) {
	            var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
	            var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 0xff;
	            var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 0xff;
	            var triplet = byte1 << 16 | byte2 << 8 | byte3;

	            for (var j = 0; j < 4 && i + j * 0.75 < sigBytes; j++) {
	              base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 0x3f));
	            }
	          } // Add padding


	          var paddingChar = map.charAt(64);

	          if (paddingChar) {
	            while (base64Chars.length % 4) {
	              base64Chars.push(paddingChar);
	            }
	          }

	          return base64Chars.join('');
	        },

	        /**
	         * Converts a Base64 string to a word array.
	         *
	         * @param {string} base64Str The Base64 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
	         */
	        parse: function (base64Str) {
	          // Shortcuts
	          var base64StrLength = base64Str.length;
	          var map = this._map;
	          var reverseMap = this._reverseMap;

	          if (!reverseMap) {
	            reverseMap = this._reverseMap = [];

	            for (var j = 0; j < map.length; j++) {
	              reverseMap[map.charCodeAt(j)] = j;
	            }
	          } // Ignore padding


	          var paddingChar = map.charAt(64);

	          if (paddingChar) {
	            var paddingIndex = base64Str.indexOf(paddingChar);

	            if (paddingIndex !== -1) {
	              base64StrLength = paddingIndex;
	            }
	          } // Convert


	          return parseLoop(base64Str, base64StrLength, reverseMap);
	        },
	        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
	      };

	      function parseLoop(base64Str, base64StrLength, reverseMap) {
	        var words = [];
	        var nBytes = 0;

	        for (var i = 0; i < base64StrLength; i++) {
	          if (i % 4) {
	            var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
	            var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
	            var bitsCombined = bits1 | bits2;
	            words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
	            nBytes++;
	          }
	        }

	        return WordArray.create(words, nBytes);
	      }
	    })();

	    return CryptoJS.enc.Base64;
	  });
	});

	var md5 = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory(core);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function (Math) {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var WordArray = C_lib.WordArray;
	      var Hasher = C_lib.Hasher;
	      var C_algo = C.algo; // Constants table

	      var T = []; // Compute constants

	      (function () {
	        for (var i = 0; i < 64; i++) {
	          T[i] = Math.abs(Math.sin(i + 1)) * 0x100000000 | 0;
	        }
	      })();
	      /**
	       * MD5 hash algorithm.
	       */


	      var MD5 = C_algo.MD5 = Hasher.extend({
	        _doReset: function () {
	          this._hash = new WordArray.init([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]);
	        },
	        _doProcessBlock: function (M, offset) {
	          // Swap endian
	          for (var i = 0; i < 16; i++) {
	            // Shortcuts
	            var offset_i = offset + i;
	            var M_offset_i = M[offset_i];
	            M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 0x00ff00ff | (M_offset_i << 24 | M_offset_i >>> 8) & 0xff00ff00;
	          } // Shortcuts


	          var H = this._hash.words;
	          var M_offset_0 = M[offset + 0];
	          var M_offset_1 = M[offset + 1];
	          var M_offset_2 = M[offset + 2];
	          var M_offset_3 = M[offset + 3];
	          var M_offset_4 = M[offset + 4];
	          var M_offset_5 = M[offset + 5];
	          var M_offset_6 = M[offset + 6];
	          var M_offset_7 = M[offset + 7];
	          var M_offset_8 = M[offset + 8];
	          var M_offset_9 = M[offset + 9];
	          var M_offset_10 = M[offset + 10];
	          var M_offset_11 = M[offset + 11];
	          var M_offset_12 = M[offset + 12];
	          var M_offset_13 = M[offset + 13];
	          var M_offset_14 = M[offset + 14];
	          var M_offset_15 = M[offset + 15]; // Working varialbes

	          var a = H[0];
	          var b = H[1];
	          var c = H[2];
	          var d = H[3]; // Computation

	          a = FF(a, b, c, d, M_offset_0, 7, T[0]);
	          d = FF(d, a, b, c, M_offset_1, 12, T[1]);
	          c = FF(c, d, a, b, M_offset_2, 17, T[2]);
	          b = FF(b, c, d, a, M_offset_3, 22, T[3]);
	          a = FF(a, b, c, d, M_offset_4, 7, T[4]);
	          d = FF(d, a, b, c, M_offset_5, 12, T[5]);
	          c = FF(c, d, a, b, M_offset_6, 17, T[6]);
	          b = FF(b, c, d, a, M_offset_7, 22, T[7]);
	          a = FF(a, b, c, d, M_offset_8, 7, T[8]);
	          d = FF(d, a, b, c, M_offset_9, 12, T[9]);
	          c = FF(c, d, a, b, M_offset_10, 17, T[10]);
	          b = FF(b, c, d, a, M_offset_11, 22, T[11]);
	          a = FF(a, b, c, d, M_offset_12, 7, T[12]);
	          d = FF(d, a, b, c, M_offset_13, 12, T[13]);
	          c = FF(c, d, a, b, M_offset_14, 17, T[14]);
	          b = FF(b, c, d, a, M_offset_15, 22, T[15]);
	          a = GG(a, b, c, d, M_offset_1, 5, T[16]);
	          d = GG(d, a, b, c, M_offset_6, 9, T[17]);
	          c = GG(c, d, a, b, M_offset_11, 14, T[18]);
	          b = GG(b, c, d, a, M_offset_0, 20, T[19]);
	          a = GG(a, b, c, d, M_offset_5, 5, T[20]);
	          d = GG(d, a, b, c, M_offset_10, 9, T[21]);
	          c = GG(c, d, a, b, M_offset_15, 14, T[22]);
	          b = GG(b, c, d, a, M_offset_4, 20, T[23]);
	          a = GG(a, b, c, d, M_offset_9, 5, T[24]);
	          d = GG(d, a, b, c, M_offset_14, 9, T[25]);
	          c = GG(c, d, a, b, M_offset_3, 14, T[26]);
	          b = GG(b, c, d, a, M_offset_8, 20, T[27]);
	          a = GG(a, b, c, d, M_offset_13, 5, T[28]);
	          d = GG(d, a, b, c, M_offset_2, 9, T[29]);
	          c = GG(c, d, a, b, M_offset_7, 14, T[30]);
	          b = GG(b, c, d, a, M_offset_12, 20, T[31]);
	          a = HH(a, b, c, d, M_offset_5, 4, T[32]);
	          d = HH(d, a, b, c, M_offset_8, 11, T[33]);
	          c = HH(c, d, a, b, M_offset_11, 16, T[34]);
	          b = HH(b, c, d, a, M_offset_14, 23, T[35]);
	          a = HH(a, b, c, d, M_offset_1, 4, T[36]);
	          d = HH(d, a, b, c, M_offset_4, 11, T[37]);
	          c = HH(c, d, a, b, M_offset_7, 16, T[38]);
	          b = HH(b, c, d, a, M_offset_10, 23, T[39]);
	          a = HH(a, b, c, d, M_offset_13, 4, T[40]);
	          d = HH(d, a, b, c, M_offset_0, 11, T[41]);
	          c = HH(c, d, a, b, M_offset_3, 16, T[42]);
	          b = HH(b, c, d, a, M_offset_6, 23, T[43]);
	          a = HH(a, b, c, d, M_offset_9, 4, T[44]);
	          d = HH(d, a, b, c, M_offset_12, 11, T[45]);
	          c = HH(c, d, a, b, M_offset_15, 16, T[46]);
	          b = HH(b, c, d, a, M_offset_2, 23, T[47]);
	          a = II(a, b, c, d, M_offset_0, 6, T[48]);
	          d = II(d, a, b, c, M_offset_7, 10, T[49]);
	          c = II(c, d, a, b, M_offset_14, 15, T[50]);
	          b = II(b, c, d, a, M_offset_5, 21, T[51]);
	          a = II(a, b, c, d, M_offset_12, 6, T[52]);
	          d = II(d, a, b, c, M_offset_3, 10, T[53]);
	          c = II(c, d, a, b, M_offset_10, 15, T[54]);
	          b = II(b, c, d, a, M_offset_1, 21, T[55]);
	          a = II(a, b, c, d, M_offset_8, 6, T[56]);
	          d = II(d, a, b, c, M_offset_15, 10, T[57]);
	          c = II(c, d, a, b, M_offset_6, 15, T[58]);
	          b = II(b, c, d, a, M_offset_13, 21, T[59]);
	          a = II(a, b, c, d, M_offset_4, 6, T[60]);
	          d = II(d, a, b, c, M_offset_11, 10, T[61]);
	          c = II(c, d, a, b, M_offset_2, 15, T[62]);
	          b = II(b, c, d, a, M_offset_9, 21, T[63]); // Intermediate hash value

	          H[0] = H[0] + a | 0;
	          H[1] = H[1] + b | 0;
	          H[2] = H[2] + c | 0;
	          H[3] = H[3] + d | 0;
	        },
	        _doFinalize: function () {
	          // Shortcuts
	          var data = this._data;
	          var dataWords = data.words;
	          var nBitsTotal = this._nDataBytes * 8;
	          var nBitsLeft = data.sigBytes * 8; // Add padding

	          dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
	          var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
	          var nBitsTotalL = nBitsTotal;
	          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 0x00ff00ff | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 0xff00ff00;
	          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 0x00ff00ff | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 0xff00ff00;
	          data.sigBytes = (dataWords.length + 1) * 4; // Hash final blocks

	          this._process(); // Shortcuts


	          var hash = this._hash;
	          var H = hash.words; // Swap endian

	          for (var i = 0; i < 4; i++) {
	            // Shortcut
	            var H_i = H[i];
	            H[i] = (H_i << 8 | H_i >>> 24) & 0x00ff00ff | (H_i << 24 | H_i >>> 8) & 0xff00ff00;
	          } // Return final computed hash


	          return hash;
	        },
	        clone: function () {
	          var clone = Hasher.clone.call(this);
	          clone._hash = this._hash.clone();
	          return clone;
	        }
	      });

	      function FF(a, b, c, d, x, s, t) {
	        var n = a + (b & c | ~b & d) + x + t;
	        return (n << s | n >>> 32 - s) + b;
	      }

	      function GG(a, b, c, d, x, s, t) {
	        var n = a + (b & d | c & ~d) + x + t;
	        return (n << s | n >>> 32 - s) + b;
	      }

	      function HH(a, b, c, d, x, s, t) {
	        var n = a + (b ^ c ^ d) + x + t;
	        return (n << s | n >>> 32 - s) + b;
	      }

	      function II(a, b, c, d, x, s, t) {
	        var n = a + (c ^ (b | ~d)) + x + t;
	        return (n << s | n >>> 32 - s) + b;
	      }
	      /**
	       * Shortcut function to the hasher's object interface.
	       *
	       * @param {WordArray|string} message The message to hash.
	       *
	       * @return {WordArray} The hash.
	       *
	       * @static
	       *
	       * @example
	       *
	       *     var hash = CryptoJS.MD5('message');
	       *     var hash = CryptoJS.MD5(wordArray);
	       */


	      C.MD5 = Hasher._createHelper(MD5);
	      /**
	       * Shortcut function to the HMAC's object interface.
	       *
	       * @param {WordArray|string} message The message to hash.
	       * @param {WordArray|string} key The secret key.
	       *
	       * @return {WordArray} The HMAC.
	       *
	       * @static
	       *
	       * @example
	       *
	       *     var hmac = CryptoJS.HmacMD5(message, key);
	       */

	      C.HmacMD5 = Hasher._createHmacHelper(MD5);
	    })(Math);

	    return CryptoJS.MD5;
	  });
	});

	var sha1 = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory(core);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function () {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var WordArray = C_lib.WordArray;
	      var Hasher = C_lib.Hasher;
	      var C_algo = C.algo; // Reusable object

	      var W = [];
	      /**
	       * SHA-1 hash algorithm.
	       */

	      var SHA1 = C_algo.SHA1 = Hasher.extend({
	        _doReset: function () {
	          this._hash = new WordArray.init([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
	        },
	        _doProcessBlock: function (M, offset) {
	          // Shortcut
	          var H = this._hash.words; // Working variables

	          var a = H[0];
	          var b = H[1];
	          var c = H[2];
	          var d = H[3];
	          var e = H[4]; // Computation

	          for (var i = 0; i < 80; i++) {
	            if (i < 16) {
	              W[i] = M[offset + i] | 0;
	            } else {
	              var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
	              W[i] = n << 1 | n >>> 31;
	            }

	            var t = (a << 5 | a >>> 27) + e + W[i];

	            if (i < 20) {
	              t += (b & c | ~b & d) + 0x5a827999;
	            } else if (i < 40) {
	              t += (b ^ c ^ d) + 0x6ed9eba1;
	            } else if (i < 60) {
	              t += (b & c | b & d | c & d) - 0x70e44324;
	            } else
	              /* if (i < 80) */
	              {
	                t += (b ^ c ^ d) - 0x359d3e2a;
	              }

	            e = d;
	            d = c;
	            c = b << 30 | b >>> 2;
	            b = a;
	            a = t;
	          } // Intermediate hash value


	          H[0] = H[0] + a | 0;
	          H[1] = H[1] + b | 0;
	          H[2] = H[2] + c | 0;
	          H[3] = H[3] + d | 0;
	          H[4] = H[4] + e | 0;
	        },
	        _doFinalize: function () {
	          // Shortcuts
	          var data = this._data;
	          var dataWords = data.words;
	          var nBitsTotal = this._nDataBytes * 8;
	          var nBitsLeft = data.sigBytes * 8; // Add padding

	          dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
	          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
	          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
	          data.sigBytes = dataWords.length * 4; // Hash final blocks

	          this._process(); // Return final computed hash


	          return this._hash;
	        },
	        clone: function () {
	          var clone = Hasher.clone.call(this);
	          clone._hash = this._hash.clone();
	          return clone;
	        }
	      });
	      /**
	       * Shortcut function to the hasher's object interface.
	       *
	       * @param {WordArray|string} message The message to hash.
	       *
	       * @return {WordArray} The hash.
	       *
	       * @static
	       *
	       * @example
	       *
	       *     var hash = CryptoJS.SHA1('message');
	       *     var hash = CryptoJS.SHA1(wordArray);
	       */

	      C.SHA1 = Hasher._createHelper(SHA1);
	      /**
	       * Shortcut function to the HMAC's object interface.
	       *
	       * @param {WordArray|string} message The message to hash.
	       * @param {WordArray|string} key The secret key.
	       *
	       * @return {WordArray} The HMAC.
	       *
	       * @static
	       *
	       * @example
	       *
	       *     var hmac = CryptoJS.HmacSHA1(message, key);
	       */

	      C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
	    })();

	    return CryptoJS.SHA1;
	  });
	});

	var hmac = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory(core);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function () {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var Base = C_lib.Base;
	      var C_enc = C.enc;
	      var Utf8 = C_enc.Utf8;
	      var C_algo = C.algo;
	      /**
	       * HMAC algorithm.
	       */

	      C_algo.HMAC = Base.extend({
	        /**
	         * Initializes a newly created HMAC.
	         *
	         * @param {Hasher} hasher The hash algorithm to use.
	         * @param {WordArray|string} key The secret key.
	         *
	         * @example
	         *
	         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
	         */
	        init: function (hasher, key) {
	          // Init hasher
	          hasher = this._hasher = new hasher.init(); // Convert string to WordArray, else assume WordArray already

	          if (typeof key == 'string') {
	            key = Utf8.parse(key);
	          } // Shortcuts


	          var hasherBlockSize = hasher.blockSize;
	          var hasherBlockSizeBytes = hasherBlockSize * 4; // Allow arbitrary length keys

	          if (key.sigBytes > hasherBlockSizeBytes) {
	            key = hasher.finalize(key);
	          } // Clamp excess bits


	          key.clamp(); // Clone key for inner and outer pads

	          var oKey = this._oKey = key.clone();
	          var iKey = this._iKey = key.clone(); // Shortcuts

	          var oKeyWords = oKey.words;
	          var iKeyWords = iKey.words; // XOR keys with pad constants

	          for (var i = 0; i < hasherBlockSize; i++) {
	            oKeyWords[i] ^= 0x5c5c5c5c;
	            iKeyWords[i] ^= 0x36363636;
	          }

	          oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes; // Set initial values

	          this.reset();
	        },

	        /**
	         * Resets this HMAC to its initial state.
	         *
	         * @example
	         *
	         *     hmacHasher.reset();
	         */
	        reset: function () {
	          // Shortcut
	          var hasher = this._hasher; // Reset

	          hasher.reset();
	          hasher.update(this._iKey);
	        },

	        /**
	         * Updates this HMAC with a message.
	         *
	         * @param {WordArray|string} messageUpdate The message to append.
	         *
	         * @return {HMAC} This HMAC instance.
	         *
	         * @example
	         *
	         *     hmacHasher.update('message');
	         *     hmacHasher.update(wordArray);
	         */
	        update: function (messageUpdate) {
	          this._hasher.update(messageUpdate); // Chainable


	          return this;
	        },

	        /**
	         * Finalizes the HMAC computation.
	         * Note that the finalize operation is effectively a destructive, read-once operation.
	         *
	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
	         *
	         * @return {WordArray} The HMAC.
	         *
	         * @example
	         *
	         *     var hmac = hmacHasher.finalize();
	         *     var hmac = hmacHasher.finalize('message');
	         *     var hmac = hmacHasher.finalize(wordArray);
	         */
	        finalize: function (messageUpdate) {
	          // Shortcut
	          var hasher = this._hasher; // Compute HMAC

	          var innerHash = hasher.finalize(messageUpdate);
	          hasher.reset();
	          var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
	          return hmac;
	        }
	      });
	    })();
	  });
	});

	var evpkdf = createCommonjsModule(function (module, exports) {

	  (function (root, factory, undef) {
	    {
	      // CommonJS
	      module.exports = factory(core, sha1, hmac);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function () {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var Base = C_lib.Base;
	      var WordArray = C_lib.WordArray;
	      var C_algo = C.algo;
	      var MD5 = C_algo.MD5;
	      /**
	       * This key derivation function is meant to conform with EVP_BytesToKey.
	       * www.openssl.org/docs/crypto/EVP_BytesToKey.html
	       */

	      var EvpKDF = C_algo.EvpKDF = Base.extend({
	        /**
	         * Configuration options.
	         *
	         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
	         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
	         * @property {number} iterations The number of iterations to perform. Default: 1
	         */
	        cfg: Base.extend({
	          keySize: 128 / 32,
	          hasher: MD5,
	          iterations: 1
	        }),

	        /**
	         * Initializes a newly created key derivation function.
	         *
	         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
	         *
	         * @example
	         *
	         *     var kdf = CryptoJS.algo.EvpKDF.create();
	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
	         */
	        init: function (cfg) {
	          this.cfg = this.cfg.extend(cfg);
	        },

	        /**
	         * Derives a key from a password.
	         *
	         * @param {WordArray|string} password The password.
	         * @param {WordArray|string} salt A salt.
	         *
	         * @return {WordArray} The derived key.
	         *
	         * @example
	         *
	         *     var key = kdf.compute(password, salt);
	         */
	        compute: function (password, salt) {
	          var block; // Shortcut

	          var cfg = this.cfg; // Init hasher

	          var hasher = cfg.hasher.create(); // Initial values

	          var derivedKey = WordArray.create(); // Shortcuts

	          var derivedKeyWords = derivedKey.words;
	          var keySize = cfg.keySize;
	          var iterations = cfg.iterations; // Generate key

	          while (derivedKeyWords.length < keySize) {
	            if (block) {
	              hasher.update(block);
	            }

	            block = hasher.update(password).finalize(salt);
	            hasher.reset(); // Iterations

	            for (var i = 1; i < iterations; i++) {
	              block = hasher.finalize(block);
	              hasher.reset();
	            }

	            derivedKey.concat(block);
	          }

	          derivedKey.sigBytes = keySize * 4;
	          return derivedKey;
	        }
	      });
	      /**
	       * Derives a key from a password.
	       *
	       * @param {WordArray|string} password The password.
	       * @param {WordArray|string} salt A salt.
	       * @param {Object} cfg (Optional) The configuration options to use for this computation.
	       *
	       * @return {WordArray} The derived key.
	       *
	       * @static
	       *
	       * @example
	       *
	       *     var key = CryptoJS.EvpKDF(password, salt);
	       *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
	       *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
	       */

	      C.EvpKDF = function (password, salt, cfg) {
	        return EvpKDF.create(cfg).compute(password, salt);
	      };
	    })();

	    return CryptoJS.EvpKDF;
	  });
	});

	var cipherCore = createCommonjsModule(function (module, exports) {

	  (function (root, factory, undef) {
	    {
	      // CommonJS
	      module.exports = factory(core, evpkdf);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    /**
	     * Cipher core components.
	     */
	    CryptoJS.lib.Cipher || function (undefined$1) {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var Base = C_lib.Base;
	      var WordArray = C_lib.WordArray;
	      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
	      var C_enc = C.enc;
	      C_enc.Utf8;
	      var Base64 = C_enc.Base64;
	      var C_algo = C.algo;
	      var EvpKDF = C_algo.EvpKDF;
	      /**
	       * Abstract base cipher template.
	       *
	       * @property {number} keySize This cipher's key size. Default: 4 (128 bits)
	       * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
	       * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
	       * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
	       */

	      var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
	        /**
	         * Configuration options.
	         *
	         * @property {WordArray} iv The IV to use for this operation.
	         */
	        cfg: Base.extend(),

	        /**
	         * Creates this cipher in encryption mode.
	         *
	         * @param {WordArray} key The key.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {Cipher} A cipher instance.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
	         */
	        createEncryptor: function (key, cfg) {
	          return this.create(this._ENC_XFORM_MODE, key, cfg);
	        },

	        /**
	         * Creates this cipher in decryption mode.
	         *
	         * @param {WordArray} key The key.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {Cipher} A cipher instance.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
	         */
	        createDecryptor: function (key, cfg) {
	          return this.create(this._DEC_XFORM_MODE, key, cfg);
	        },

	        /**
	         * Initializes a newly created cipher.
	         *
	         * @param {number} xformMode Either the encryption or decryption transormation mode constant.
	         * @param {WordArray} key The key.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @example
	         *
	         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
	         */
	        init: function (xformMode, key, cfg) {
	          // Apply config defaults
	          this.cfg = this.cfg.extend(cfg); // Store transform mode and key

	          this._xformMode = xformMode;
	          this._key = key; // Set initial values

	          this.reset();
	        },

	        /**
	         * Resets this cipher to its initial state.
	         *
	         * @example
	         *
	         *     cipher.reset();
	         */
	        reset: function () {
	          // Reset data buffer
	          BufferedBlockAlgorithm.reset.call(this); // Perform concrete-cipher logic

	          this._doReset();
	        },

	        /**
	         * Adds data to be encrypted or decrypted.
	         *
	         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
	         *
	         * @return {WordArray} The data after processing.
	         *
	         * @example
	         *
	         *     var encrypted = cipher.process('data');
	         *     var encrypted = cipher.process(wordArray);
	         */
	        process: function (dataUpdate) {
	          // Append
	          this._append(dataUpdate); // Process available blocks


	          return this._process();
	        },

	        /**
	         * Finalizes the encryption or decryption process.
	         * Note that the finalize operation is effectively a destructive, read-once operation.
	         *
	         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
	         *
	         * @return {WordArray} The data after final processing.
	         *
	         * @example
	         *
	         *     var encrypted = cipher.finalize();
	         *     var encrypted = cipher.finalize('data');
	         *     var encrypted = cipher.finalize(wordArray);
	         */
	        finalize: function (dataUpdate) {
	          // Final data update
	          if (dataUpdate) {
	            this._append(dataUpdate);
	          } // Perform concrete-cipher logic


	          var finalProcessedData = this._doFinalize();

	          return finalProcessedData;
	        },
	        keySize: 128 / 32,
	        ivSize: 128 / 32,
	        _ENC_XFORM_MODE: 1,
	        _DEC_XFORM_MODE: 2,

	        /**
	         * Creates shortcut functions to a cipher's object interface.
	         *
	         * @param {Cipher} cipher The cipher to create a helper for.
	         *
	         * @return {Object} An object with encrypt and decrypt shortcut functions.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
	         */
	        _createHelper: function () {
	          function selectCipherStrategy(key) {
	            if (typeof key == 'string') {
	              return PasswordBasedCipher;
	            } else {
	              return SerializableCipher;
	            }
	          }

	          return function (cipher) {
	            return {
	              encrypt: function (message, key, cfg) {
	                return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
	              },
	              decrypt: function (ciphertext, key, cfg) {
	                return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
	              }
	            };
	          };
	        }()
	      });
	      /**
	       * Abstract base stream cipher template.
	       *
	       * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
	       */

	      C_lib.StreamCipher = Cipher.extend({
	        _doFinalize: function () {
	          // Process partial blocks
	          var finalProcessedBlocks = this._process(!!'flush');

	          return finalProcessedBlocks;
	        },
	        blockSize: 1
	      });
	      /**
	       * Mode namespace.
	       */

	      var C_mode = C.mode = {};
	      /**
	       * Abstract base block cipher mode template.
	       */

	      var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
	        /**
	         * Creates this mode for encryption.
	         *
	         * @param {Cipher} cipher A block cipher instance.
	         * @param {Array} iv The IV words.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
	         */
	        createEncryptor: function (cipher, iv) {
	          return this.Encryptor.create(cipher, iv);
	        },

	        /**
	         * Creates this mode for decryption.
	         *
	         * @param {Cipher} cipher A block cipher instance.
	         * @param {Array} iv The IV words.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
	         */
	        createDecryptor: function (cipher, iv) {
	          return this.Decryptor.create(cipher, iv);
	        },

	        /**
	         * Initializes a newly created mode.
	         *
	         * @param {Cipher} cipher A block cipher instance.
	         * @param {Array} iv The IV words.
	         *
	         * @example
	         *
	         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
	         */
	        init: function (cipher, iv) {
	          this._cipher = cipher;
	          this._iv = iv;
	        }
	      });
	      /**
	       * Cipher Block Chaining mode.
	       */

	      var CBC = C_mode.CBC = function () {
	        /**
	         * Abstract base CBC mode.
	         */
	        var CBC = BlockCipherMode.extend();
	        /**
	         * CBC encryptor.
	         */

	        CBC.Encryptor = CBC.extend({
	          /**
	           * Processes the data block at offset.
	           *
	           * @param {Array} words The data words to operate on.
	           * @param {number} offset The offset where the block starts.
	           *
	           * @example
	           *
	           *     mode.processBlock(data.words, offset);
	           */
	          processBlock: function (words, offset) {
	            // Shortcuts
	            var cipher = this._cipher;
	            var blockSize = cipher.blockSize; // XOR and encrypt

	            xorBlock.call(this, words, offset, blockSize);
	            cipher.encryptBlock(words, offset); // Remember this block to use with next block

	            this._prevBlock = words.slice(offset, offset + blockSize);
	          }
	        });
	        /**
	         * CBC decryptor.
	         */

	        CBC.Decryptor = CBC.extend({
	          /**
	           * Processes the data block at offset.
	           *
	           * @param {Array} words The data words to operate on.
	           * @param {number} offset The offset where the block starts.
	           *
	           * @example
	           *
	           *     mode.processBlock(data.words, offset);
	           */
	          processBlock: function (words, offset) {
	            // Shortcuts
	            var cipher = this._cipher;
	            var blockSize = cipher.blockSize; // Remember this block to use with next block

	            var thisBlock = words.slice(offset, offset + blockSize); // Decrypt and XOR

	            cipher.decryptBlock(words, offset);
	            xorBlock.call(this, words, offset, blockSize); // This block becomes the previous block

	            this._prevBlock = thisBlock;
	          }
	        });

	        function xorBlock(words, offset, blockSize) {
	          var block; // Shortcut

	          var iv = this._iv; // Choose mixing block

	          if (iv) {
	            block = iv; // Remove IV for subsequent blocks

	            this._iv = undefined$1;
	          } else {
	            block = this._prevBlock;
	          } // XOR blocks


	          for (var i = 0; i < blockSize; i++) {
	            words[offset + i] ^= block[i];
	          }
	        }

	        return CBC;
	      }();
	      /**
	       * Padding namespace.
	       */


	      var C_pad = C.pad = {};
	      /**
	       * PKCS #5/7 padding strategy.
	       */

	      var Pkcs7 = C_pad.Pkcs7 = {
	        /**
	         * Pads data using the algorithm defined in PKCS #5/7.
	         *
	         * @param {WordArray} data The data to pad.
	         * @param {number} blockSize The multiple that the data should be padded to.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
	         */
	        pad: function (data, blockSize) {
	          // Shortcut
	          var blockSizeBytes = blockSize * 4; // Count padding bytes

	          var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; // Create padding word

	          var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes; // Create padding

	          var paddingWords = [];

	          for (var i = 0; i < nPaddingBytes; i += 4) {
	            paddingWords.push(paddingWord);
	          }

	          var padding = WordArray.create(paddingWords, nPaddingBytes); // Add padding

	          data.concat(padding);
	        },

	        /**
	         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
	         *
	         * @param {WordArray} data The data to unpad.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     CryptoJS.pad.Pkcs7.unpad(wordArray);
	         */
	        unpad: function (data) {
	          // Get number of padding bytes from last byte
	          var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 0xff; // Remove padding

	          data.sigBytes -= nPaddingBytes;
	        }
	      };
	      /**
	       * Abstract base block cipher template.
	       *
	       * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
	       */

	      C_lib.BlockCipher = Cipher.extend({
	        /**
	         * Configuration options.
	         *
	         * @property {Mode} mode The block mode to use. Default: CBC
	         * @property {Padding} padding The padding strategy to use. Default: Pkcs7
	         */
	        cfg: Cipher.cfg.extend({
	          mode: CBC,
	          padding: Pkcs7
	        }),
	        reset: function () {
	          var modeCreator; // Reset cipher

	          Cipher.reset.call(this); // Shortcuts

	          var cfg = this.cfg;
	          var iv = cfg.iv;
	          var mode = cfg.mode; // Reset block mode

	          if (this._xformMode == this._ENC_XFORM_MODE) {
	            modeCreator = mode.createEncryptor;
	          } else
	            /* if (this._xformMode == this._DEC_XFORM_MODE) */
	            {
	              modeCreator = mode.createDecryptor; // Keep at least one block in the buffer for unpadding

	              this._minBufferSize = 1;
	            }

	          if (this._mode && this._mode.__creator == modeCreator) {
	            this._mode.init(this, iv && iv.words);
	          } else {
	            this._mode = modeCreator.call(mode, this, iv && iv.words);
	            this._mode.__creator = modeCreator;
	          }
	        },
	        _doProcessBlock: function (words, offset) {
	          this._mode.processBlock(words, offset);
	        },
	        _doFinalize: function () {
	          var finalProcessedBlocks; // Shortcut

	          var padding = this.cfg.padding; // Finalize

	          if (this._xformMode == this._ENC_XFORM_MODE) {
	            // Pad data
	            padding.pad(this._data, this.blockSize); // Process final blocks

	            finalProcessedBlocks = this._process(!!'flush');
	          } else
	            /* if (this._xformMode == this._DEC_XFORM_MODE) */
	            {
	              // Process final blocks
	              finalProcessedBlocks = this._process(!!'flush'); // Unpad data

	              padding.unpad(finalProcessedBlocks);
	            }

	          return finalProcessedBlocks;
	        },
	        blockSize: 128 / 32
	      });
	      /**
	       * A collection of cipher parameters.
	       *
	       * @property {WordArray} ciphertext The raw ciphertext.
	       * @property {WordArray} key The key to this ciphertext.
	       * @property {WordArray} iv The IV used in the ciphering operation.
	       * @property {WordArray} salt The salt used with a key derivation function.
	       * @property {Cipher} algorithm The cipher algorithm.
	       * @property {Mode} mode The block mode used in the ciphering operation.
	       * @property {Padding} padding The padding scheme used in the ciphering operation.
	       * @property {number} blockSize The block size of the cipher.
	       * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
	       */

	      var CipherParams = C_lib.CipherParams = Base.extend({
	        /**
	         * Initializes a newly created cipher params object.
	         *
	         * @param {Object} cipherParams An object with any of the possible cipher parameters.
	         *
	         * @example
	         *
	         *     var cipherParams = CryptoJS.lib.CipherParams.create({
	         *         ciphertext: ciphertextWordArray,
	         *         key: keyWordArray,
	         *         iv: ivWordArray,
	         *         salt: saltWordArray,
	         *         algorithm: CryptoJS.algo.AES,
	         *         mode: CryptoJS.mode.CBC,
	         *         padding: CryptoJS.pad.PKCS7,
	         *         blockSize: 4,
	         *         formatter: CryptoJS.format.OpenSSL
	         *     });
	         */
	        init: function (cipherParams) {
	          this.mixIn(cipherParams);
	        },

	        /**
	         * Converts this cipher params object to a string.
	         *
	         * @param {Format} formatter (Optional) The formatting strategy to use.
	         *
	         * @return {string} The stringified cipher params.
	         *
	         * @throws Error If neither the formatter nor the default formatter is set.
	         *
	         * @example
	         *
	         *     var string = cipherParams + '';
	         *     var string = cipherParams.toString();
	         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
	         */
	        toString: function (formatter) {
	          return (formatter || this.formatter).stringify(this);
	        }
	      });
	      /**
	       * Format namespace.
	       */

	      var C_format = C.format = {};
	      /**
	       * OpenSSL formatting strategy.
	       */

	      var OpenSSLFormatter = C_format.OpenSSL = {
	        /**
	         * Converts a cipher params object to an OpenSSL-compatible string.
	         *
	         * @param {CipherParams} cipherParams The cipher params object.
	         *
	         * @return {string} The OpenSSL-compatible string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
	         */
	        stringify: function (cipherParams) {
	          var wordArray; // Shortcuts

	          var ciphertext = cipherParams.ciphertext;
	          var salt = cipherParams.salt; // Format

	          if (salt) {
	            wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
	          } else {
	            wordArray = ciphertext;
	          }

	          return wordArray.toString(Base64);
	        },

	        /**
	         * Converts an OpenSSL-compatible string to a cipher params object.
	         *
	         * @param {string} openSSLStr The OpenSSL-compatible string.
	         *
	         * @return {CipherParams} The cipher params object.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
	         */
	        parse: function (openSSLStr) {
	          var salt; // Parse base64

	          var ciphertext = Base64.parse(openSSLStr); // Shortcut

	          var ciphertextWords = ciphertext.words; // Test for salt

	          if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
	            // Extract salt
	            salt = WordArray.create(ciphertextWords.slice(2, 4)); // Remove salt from ciphertext

	            ciphertextWords.splice(0, 4);
	            ciphertext.sigBytes -= 16;
	          }

	          return CipherParams.create({
	            ciphertext: ciphertext,
	            salt: salt
	          });
	        }
	      };
	      /**
	       * A cipher wrapper that returns ciphertext as a serializable cipher params object.
	       */

	      var SerializableCipher = C_lib.SerializableCipher = Base.extend({
	        /**
	         * Configuration options.
	         *
	         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
	         */
	        cfg: Base.extend({
	          format: OpenSSLFormatter
	        }),

	        /**
	         * Encrypts a message.
	         *
	         * @param {Cipher} cipher The cipher algorithm to use.
	         * @param {WordArray|string} message The message to encrypt.
	         * @param {WordArray} key The key.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {CipherParams} A cipher params object.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
	         */
	        encrypt: function (cipher, message, key, cfg) {
	          // Apply config defaults
	          cfg = this.cfg.extend(cfg); // Encrypt

	          var encryptor = cipher.createEncryptor(key, cfg);
	          var ciphertext = encryptor.finalize(message); // Shortcut

	          var cipherCfg = encryptor.cfg; // Create and return serializable cipher params

	          return CipherParams.create({
	            ciphertext: ciphertext,
	            key: key,
	            iv: cipherCfg.iv,
	            algorithm: cipher,
	            mode: cipherCfg.mode,
	            padding: cipherCfg.padding,
	            blockSize: cipher.blockSize,
	            formatter: cfg.format
	          });
	        },

	        /**
	         * Decrypts serialized ciphertext.
	         *
	         * @param {Cipher} cipher The cipher algorithm to use.
	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
	         * @param {WordArray} key The key.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {WordArray} The plaintext.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
	         */
	        decrypt: function (cipher, ciphertext, key, cfg) {
	          // Apply config defaults
	          cfg = this.cfg.extend(cfg); // Convert string to CipherParams

	          ciphertext = this._parse(ciphertext, cfg.format); // Decrypt

	          var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
	          return plaintext;
	        },

	        /**
	         * Converts serialized ciphertext to CipherParams,
	         * else assumed CipherParams already and returns ciphertext unchanged.
	         *
	         * @param {CipherParams|string} ciphertext The ciphertext.
	         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
	         *
	         * @return {CipherParams} The unserialized ciphertext.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
	         */
	        _parse: function (ciphertext, format) {
	          if (typeof ciphertext == 'string') {
	            return format.parse(ciphertext, this);
	          } else {
	            return ciphertext;
	          }
	        }
	      });
	      /**
	       * Key derivation function namespace.
	       */

	      var C_kdf = C.kdf = {};
	      /**
	       * OpenSSL key derivation function.
	       */

	      var OpenSSLKdf = C_kdf.OpenSSL = {
	        /**
	         * Derives a key and IV from a password.
	         *
	         * @param {string} password The password to derive from.
	         * @param {number} keySize The size in words of the key to generate.
	         * @param {number} ivSize The size in words of the IV to generate.
	         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
	         *
	         * @return {CipherParams} A cipher params object with the key, IV, and salt.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
	         */
	        execute: function (password, keySize, ivSize, salt) {
	          // Generate random salt
	          if (!salt) {
	            salt = WordArray.random(64 / 8);
	          } // Derive key and IV


	          var key = EvpKDF.create({
	            keySize: keySize + ivSize
	          }).compute(password, salt); // Separate key and IV

	          var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
	          key.sigBytes = keySize * 4; // Return params

	          return CipherParams.create({
	            key: key,
	            iv: iv,
	            salt: salt
	          });
	        }
	      };
	      /**
	       * A serializable cipher wrapper that derives the key from a password,
	       * and returns ciphertext as a serializable cipher params object.
	       */

	      var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
	        /**
	         * Configuration options.
	         *
	         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
	         */
	        cfg: SerializableCipher.cfg.extend({
	          kdf: OpenSSLKdf
	        }),

	        /**
	         * Encrypts a message using a password.
	         *
	         * @param {Cipher} cipher The cipher algorithm to use.
	         * @param {WordArray|string} message The message to encrypt.
	         * @param {string} password The password.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {CipherParams} A cipher params object.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
	         */
	        encrypt: function (cipher, message, password, cfg) {
	          // Apply config defaults
	          cfg = this.cfg.extend(cfg); // Derive key and other params

	          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize); // Add IV to config

	          cfg.iv = derivedParams.iv; // Encrypt

	          var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg); // Mix in derived params

	          ciphertext.mixIn(derivedParams);
	          return ciphertext;
	        },

	        /**
	         * Decrypts serialized ciphertext using a password.
	         *
	         * @param {Cipher} cipher The cipher algorithm to use.
	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
	         * @param {string} password The password.
	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
	         *
	         * @return {WordArray} The plaintext.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
	         */
	        decrypt: function (cipher, ciphertext, password, cfg) {
	          // Apply config defaults
	          cfg = this.cfg.extend(cfg); // Convert string to CipherParams

	          ciphertext = this._parse(ciphertext, cfg.format); // Derive key and other params

	          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt); // Add IV to config

	          cfg.iv = derivedParams.iv; // Decrypt

	          var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
	          return plaintext;
	        }
	      });
	    }();
	  });
	});

	var aes = createCommonjsModule(function (module, exports) {

	  (function (root, factory, undef) {
	    {
	      // CommonJS
	      module.exports = factory(core, encBase64, md5, evpkdf, cipherCore);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    (function () {
	      // Shortcuts
	      var C = CryptoJS;
	      var C_lib = C.lib;
	      var BlockCipher = C_lib.BlockCipher;
	      var C_algo = C.algo; // Lookup tables

	      var SBOX = [];
	      var INV_SBOX = [];
	      var SUB_MIX_0 = [];
	      var SUB_MIX_1 = [];
	      var SUB_MIX_2 = [];
	      var SUB_MIX_3 = [];
	      var INV_SUB_MIX_0 = [];
	      var INV_SUB_MIX_1 = [];
	      var INV_SUB_MIX_2 = [];
	      var INV_SUB_MIX_3 = []; // Compute lookup tables

	      (function () {
	        // Compute double table
	        var d = [];

	        for (var i = 0; i < 256; i++) {
	          if (i < 128) {
	            d[i] = i << 1;
	          } else {
	            d[i] = i << 1 ^ 0x11b;
	          }
	        } // Walk GF(2^8)


	        var x = 0;
	        var xi = 0;

	        for (var i = 0; i < 256; i++) {
	          // Compute sbox
	          var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
	          sx = sx >>> 8 ^ sx & 0xff ^ 0x63;
	          SBOX[x] = sx;
	          INV_SBOX[sx] = x; // Compute multiplication

	          var x2 = d[x];
	          var x4 = d[x2];
	          var x8 = d[x4]; // Compute sub bytes, mix columns tables

	          var t = d[sx] * 0x101 ^ sx * 0x1010100;
	          SUB_MIX_0[x] = t << 24 | t >>> 8;
	          SUB_MIX_1[x] = t << 16 | t >>> 16;
	          SUB_MIX_2[x] = t << 8 | t >>> 24;
	          SUB_MIX_3[x] = t; // Compute inv sub bytes, inv mix columns tables

	          var t = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
	          INV_SUB_MIX_0[sx] = t << 24 | t >>> 8;
	          INV_SUB_MIX_1[sx] = t << 16 | t >>> 16;
	          INV_SUB_MIX_2[sx] = t << 8 | t >>> 24;
	          INV_SUB_MIX_3[sx] = t; // Compute next counter

	          if (!x) {
	            x = xi = 1;
	          } else {
	            x = x2 ^ d[d[d[x8 ^ x2]]];
	            xi ^= d[d[xi]];
	          }
	        }
	      })(); // Precomputed Rcon lookup


	      var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
	      /**
	       * AES block cipher algorithm.
	       */

	      var AES = C_algo.AES = BlockCipher.extend({
	        _doReset: function () {
	          var t; // Skip reset of nRounds has been set before and key did not change

	          if (this._nRounds && this._keyPriorReset === this._key) {
	            return;
	          } // Shortcuts


	          var key = this._keyPriorReset = this._key;
	          var keyWords = key.words;
	          var keySize = key.sigBytes / 4; // Compute number of rounds

	          var nRounds = this._nRounds = keySize + 6; // Compute number of key schedule rows

	          var ksRows = (nRounds + 1) * 4; // Compute key schedule

	          var keySchedule = this._keySchedule = [];

	          for (var ksRow = 0; ksRow < ksRows; ksRow++) {
	            if (ksRow < keySize) {
	              keySchedule[ksRow] = keyWords[ksRow];
	            } else {
	              t = keySchedule[ksRow - 1];

	              if (!(ksRow % keySize)) {
	                // Rot word
	                t = t << 8 | t >>> 24; // Sub word

	                t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 0xff] << 16 | SBOX[t >>> 8 & 0xff] << 8 | SBOX[t & 0xff]; // Mix Rcon

	                t ^= RCON[ksRow / keySize | 0] << 24;
	              } else if (keySize > 6 && ksRow % keySize == 4) {
	                // Sub word
	                t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 0xff] << 16 | SBOX[t >>> 8 & 0xff] << 8 | SBOX[t & 0xff];
	              }

	              keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
	            }
	          } // Compute inv key schedule


	          var invKeySchedule = this._invKeySchedule = [];

	          for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
	            var ksRow = ksRows - invKsRow;

	            if (invKsRow % 4) {
	              var t = keySchedule[ksRow];
	            } else {
	              var t = keySchedule[ksRow - 4];
	            }

	            if (invKsRow < 4 || ksRow <= 4) {
	              invKeySchedule[invKsRow] = t;
	            } else {
	              invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 0xff]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
	            }
	          }
	        },
	        encryptBlock: function (M, offset) {
	          this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
	        },
	        decryptBlock: function (M, offset) {
	          // Swap 2nd and 4th rows
	          var t = M[offset + 1];
	          M[offset + 1] = M[offset + 3];
	          M[offset + 3] = t;

	          this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX); // Inv swap 2nd and 4th rows


	          var t = M[offset + 1];
	          M[offset + 1] = M[offset + 3];
	          M[offset + 3] = t;
	        },
	        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
	          // Shortcut
	          var nRounds = this._nRounds; // Get input, add round key

	          var s0 = M[offset] ^ keySchedule[0];
	          var s1 = M[offset + 1] ^ keySchedule[1];
	          var s2 = M[offset + 2] ^ keySchedule[2];
	          var s3 = M[offset + 3] ^ keySchedule[3]; // Key schedule row counter

	          var ksRow = 4; // Rounds

	          for (var round = 1; round < nRounds; round++) {
	            // Shift rows, sub bytes, mix columns, add round key
	            var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[s1 >>> 16 & 0xff] ^ SUB_MIX_2[s2 >>> 8 & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
	            var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[s2 >>> 16 & 0xff] ^ SUB_MIX_2[s3 >>> 8 & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
	            var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[s3 >>> 16 & 0xff] ^ SUB_MIX_2[s0 >>> 8 & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
	            var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[s0 >>> 16 & 0xff] ^ SUB_MIX_2[s1 >>> 8 & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++]; // Update state

	            s0 = t0;
	            s1 = t1;
	            s2 = t2;
	            s3 = t3;
	          } // Shift rows, sub bytes, add round key


	          var t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 0xff] << 16 | SBOX[s2 >>> 8 & 0xff] << 8 | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
	          var t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 0xff] << 16 | SBOX[s3 >>> 8 & 0xff] << 8 | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
	          var t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 0xff] << 16 | SBOX[s0 >>> 8 & 0xff] << 8 | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
	          var t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 0xff] << 16 | SBOX[s1 >>> 8 & 0xff] << 8 | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; // Set output

	          M[offset] = t0;
	          M[offset + 1] = t1;
	          M[offset + 2] = t2;
	          M[offset + 3] = t3;
	        },
	        keySize: 256 / 32
	      });
	      /**
	       * Shortcut functions to the cipher's object interface.
	       *
	       * @example
	       *
	       *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
	       *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
	       */

	      C.AES = BlockCipher._createHelper(AES);
	    })();

	    return CryptoJS.AES;
	  });
	});

	var encUtf8 = createCommonjsModule(function (module, exports) {

	  (function (root, factory) {
	    {
	      // CommonJS
	      module.exports = factory(core);
	    }
	  })(commonjsGlobal, function (CryptoJS) {
	    return CryptoJS.enc.Utf8;
	  });
	});

	function _typeof(obj) {
	  "@babel/helpers - typeof";

	  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
	    _typeof = function (obj) {
	      return typeof obj;
	    };
	  } else {
	    _typeof = function (obj) {
	      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
	    };
	  }

	  return _typeof(obj);
	}

	// iterable DOM collections
	// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
	var domIterables = {
	  CSSRuleList: 0,
	  CSSStyleDeclaration: 0,
	  CSSValueList: 0,
	  ClientRectList: 0,
	  DOMRectList: 0,
	  DOMStringList: 0,
	  DOMTokenList: 1,
	  DataTransferItemList: 0,
	  FileList: 0,
	  HTMLAllCollection: 0,
	  HTMLCollection: 0,
	  HTMLFormElement: 0,
	  HTMLSelectElement: 0,
	  MediaList: 0,
	  MimeTypeArray: 0,
	  NamedNodeMap: 0,
	  NodeList: 1,
	  PaintRequestList: 0,
	  Plugin: 0,
	  PluginArray: 0,
	  SVGLengthList: 0,
	  SVGNumberList: 0,
	  SVGPathSegList: 0,
	  SVGPointList: 0,
	  SVGStringList: 0,
	  SVGTransformList: 0,
	  SourceBufferList: 0,
	  StyleSheetList: 0,
	  TextTrackCueList: 0,
	  TextTrackList: 0,
	  TouchList: 0
	};

	// https://tc39.es/ecma262/#sec-toobject

	var toObject = function (argument) {
	  return Object(requireObjectCoercible(argument));
	};

	// https://tc39.es/ecma262/#sec-isarray

	var isArray = Array.isArray || function isArray(arg) {
	  return classofRaw(arg) == 'Array';
	};

	var SPECIES$1 = wellKnownSymbol('species'); // `ArraySpeciesCreate` abstract operation
	// https://tc39.es/ecma262/#sec-arrayspeciescreate

	var arraySpeciesCreate = function (originalArray, length) {
	  var C;

	  if (isArray(originalArray)) {
	    C = originalArray.constructor; // cross-realm fallback

	    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;else if (isObject(C)) {
	      C = C[SPECIES$1];
	      if (C === null) C = undefined;
	    }
	  }

	  return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
	};

	var push = [].push; // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterOut }` methods implementation

	var createMethod$2 = function (TYPE) {
	  var IS_MAP = TYPE == 1;
	  var IS_FILTER = TYPE == 2;
	  var IS_SOME = TYPE == 3;
	  var IS_EVERY = TYPE == 4;
	  var IS_FIND_INDEX = TYPE == 6;
	  var IS_FILTER_OUT = TYPE == 7;
	  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
	  return function ($this, callbackfn, that, specificCreate) {
	    var O = toObject($this);
	    var self = indexedObject(O);
	    var boundFunction = functionBindContext(callbackfn, that, 3);
	    var length = toLength(self.length);
	    var index = 0;
	    var create = specificCreate || arraySpeciesCreate;
	    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_OUT ? create($this, 0) : undefined;
	    var value, result;

	    for (; length > index; index++) if (NO_HOLES || index in self) {
	      value = self[index];
	      result = boundFunction(value, index, O);

	      if (TYPE) {
	        if (IS_MAP) target[index] = result; // map
	        else if (result) switch (TYPE) {
	            case 3:
	              return true;
	            // some

	            case 5:
	              return value;
	            // find

	            case 6:
	              return index;
	            // findIndex

	            case 2:
	              push.call(target, value);
	            // filter
	          } else switch (TYPE) {
	            case 4:
	              return false;
	            // every

	            case 7:
	              push.call(target, value);
	            // filterOut
	          }
	      }
	    }

	    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
	  };
	};

	var arrayIteration = {
	  // `Array.prototype.forEach` method
	  // https://tc39.es/ecma262/#sec-array.prototype.foreach
	  forEach: createMethod$2(0),
	  // `Array.prototype.map` method
	  // https://tc39.es/ecma262/#sec-array.prototype.map
	  map: createMethod$2(1),
	  // `Array.prototype.filter` method
	  // https://tc39.es/ecma262/#sec-array.prototype.filter
	  filter: createMethod$2(2),
	  // `Array.prototype.some` method
	  // https://tc39.es/ecma262/#sec-array.prototype.some
	  some: createMethod$2(3),
	  // `Array.prototype.every` method
	  // https://tc39.es/ecma262/#sec-array.prototype.every
	  every: createMethod$2(4),
	  // `Array.prototype.find` method
	  // https://tc39.es/ecma262/#sec-array.prototype.find
	  find: createMethod$2(5),
	  // `Array.prototype.findIndex` method
	  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
	  findIndex: createMethod$2(6),
	  // `Array.prototype.filterOut` method
	  // https://github.com/tc39/proposal-array-filtering
	  filterOut: createMethod$2(7)
	};

	var arrayMethodIsStrict = function (METHOD_NAME, argument) {
	  var method = [][METHOD_NAME];
	  return !!method && fails(function () {
	    // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing
	    method.call(null, argument || function () {
	      throw 1;
	    }, 1);
	  });
	};

	var $forEach = arrayIteration.forEach;
	var STRICT_METHOD$1 = arrayMethodIsStrict('forEach'); // `Array.prototype.forEach` method implementation
	// https://tc39.es/ecma262/#sec-array.prototype.foreach

	var arrayForEach = !STRICT_METHOD$1 ? function forEach(callbackfn
	/* , thisArg */
	) {
	  return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
	} : [].forEach;

	for (var COLLECTION_NAME in domIterables) {
	  var Collection = global$1[COLLECTION_NAME];
	  var CollectionPrototype = Collection && Collection.prototype; // some Chrome versions have non-configurable methods on DOMTokenList

	  if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try {
	    createNonEnumerableProperty(CollectionPrototype, 'forEach', arrayForEach);
	  } catch (error) {
	    CollectionPrototype.forEach = arrayForEach;
	  }
	}

	var createMethod$1 = function (IS_RIGHT) {
	  return function (that, callbackfn, argumentsLength, memo) {
	    aFunction(callbackfn);
	    var O = toObject(that);
	    var self = indexedObject(O);
	    var length = toLength(O.length);
	    var index = IS_RIGHT ? length - 1 : 0;
	    var i = IS_RIGHT ? -1 : 1;
	    if (argumentsLength < 2) while (true) {
	      if (index in self) {
	        memo = self[index];
	        index += i;
	        break;
	      }

	      index += i;

	      if (IS_RIGHT ? index < 0 : length <= index) {
	        throw TypeError('Reduce of empty array with no initial value');
	      }
	    }

	    for (; IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
	      memo = callbackfn(memo, self[index], index, O);
	    }

	    return memo;
	  };
	};

	var arrayReduce = {
	  // `Array.prototype.reduce` method
	  // https://tc39.es/ecma262/#sec-array.prototype.reduce
	  left: createMethod$1(false),
	  // `Array.prototype.reduceRight` method
	  // https://tc39.es/ecma262/#sec-array.prototype.reduceright
	  right: createMethod$1(true)
	};

	var $reduce = arrayReduce.left;
	var STRICT_METHOD = arrayMethodIsStrict('reduce'); // Chrome 80-82 has a critical bug
	// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982

	var CHROME_BUG = !engineIsNode && engineV8Version > 79 && engineV8Version < 83; // `Array.prototype.reduce` method
	// https://tc39.es/ecma262/#sec-array.prototype.reduce

	_export({
	  target: 'Array',
	  proto: true,
	  forced: !STRICT_METHOD || CHROME_BUG
	}, {
	  reduce: function reduce(callbackfn
	  /* , initialValue */
	  ) {
	    return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});

	var SPECIES = wellKnownSymbol('species');

	var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
	  // We can't use this feature detection in V8 since it causes
	  // deoptimization and serious performance degradation
	  // https://github.com/zloirock/core-js/issues/677
	  return engineV8Version >= 51 || !fails(function () {
	    var array = [];
	    var constructor = array.constructor = {};

	    constructor[SPECIES] = function () {
	      return {
	        foo: 1
	      };
	    };

	    return array[METHOD_NAME](Boolean).foo !== 1;
	  });
	};

	var $map = arrayIteration.map;
	var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map'); // `Array.prototype.map` method
	// https://tc39.es/ecma262/#sec-array.prototype.map
	// with adding support of @@species

	_export({
	  target: 'Array',
	  proto: true,
	  forced: !HAS_SPECIES_SUPPORT
	}, {
	  map: function map(callbackfn
	  /* , thisArg */
	  ) {
	    return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});

	var aPossiblePrototype = function (it) {
	  if (!isObject(it) && it !== null) {
	    throw TypeError("Can't set " + String(it) + ' as a prototype');
	  }

	  return it;
	};

	/* eslint-disable no-proto -- safe */
	// https://tc39.es/ecma262/#sec-object.setprototypeof
	// Works with __proto__ only. Old v8 can't work with null proto objects.

	var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
	  var CORRECT_SETTER = false;
	  var test = {};
	  var setter;

	  try {
	    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
	    setter.call(test, []);
	    CORRECT_SETTER = test instanceof Array;
	  } catch (error) {
	    /* empty */
	  }

	  return function setPrototypeOf(O, proto) {
	    anObject(O);
	    aPossiblePrototype(proto);
	    if (CORRECT_SETTER) setter.call(O, proto);else O.__proto__ = proto;
	    return O;
	  };
	}() : undefined);

	var inheritIfRequired = function ($this, dummy, Wrapper) {
	  var NewTarget, NewTargetPrototype;
	  if ( // it can work only with native `setPrototypeOf`
	  objectSetPrototypeOf && // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
	  typeof (NewTarget = dummy.constructor) == 'function' && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) objectSetPrototypeOf($this, NewTargetPrototype);
	  return $this;
	};

	// https://tc39.es/ecma262/#sec-object.keys

	var objectKeys = Object.keys || function keys(O) {
	  return objectKeysInternal(O, enumBugKeys);
	};

	// https://tc39.es/ecma262/#sec-object.defineproperties

	var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
	  anObject(O);
	  var keys = objectKeys(Properties);
	  var length = keys.length;
	  var index = 0;
	  var key;

	  while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]);

	  return O;
	};

	var GT = '>';
	var LT = '<';
	var PROTOTYPE = 'prototype';
	var SCRIPT = 'script';
	var IE_PROTO = sharedKey('IE_PROTO');

	var EmptyConstructor = function () {
	  /* empty */
	};

	var scriptTag = function (content) {
	  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
	}; // Create object with fake `null` prototype: use ActiveX Object with cleared prototype


	var NullProtoObjectViaActiveX = function (activeXDocument) {
	  activeXDocument.write(scriptTag(''));
	  activeXDocument.close();
	  var temp = activeXDocument.parentWindow.Object;
	  activeXDocument = null; // avoid memory leak

	  return temp;
	}; // Create object with fake `null` prototype: use iframe Object with cleared prototype


	var NullProtoObjectViaIFrame = function () {
	  // Thrash, waste and sodomy: IE GC bug
	  var iframe = documentCreateElement('iframe');
	  var JS = 'java' + SCRIPT + ':';
	  var iframeDocument;
	  iframe.style.display = 'none';
	  html.appendChild(iframe); // https://github.com/zloirock/core-js/issues/475

	  iframe.src = String(JS);
	  iframeDocument = iframe.contentWindow.document;
	  iframeDocument.open();
	  iframeDocument.write(scriptTag('document.F=Object'));
	  iframeDocument.close();
	  return iframeDocument.F;
	}; // Check for document.domain and active x support
	// No need to use active x approach when document.domain is not set
	// see https://github.com/es-shims/es5-shim/issues/150
	// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
	// avoid IE GC bug


	var activeXDocument;

	var NullProtoObject = function () {
	  try {
	    /* global ActiveXObject -- old IE */
	    activeXDocument = document.domain && new ActiveXObject('htmlfile');
	  } catch (error) {
	    /* ignore */
	  }

	  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
	  var length = enumBugKeys.length;

	  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];

	  return NullProtoObject();
	};

	hiddenKeys$1[IE_PROTO] = true; // `Object.create` method
	// https://tc39.es/ecma262/#sec-object.create

	var objectCreate = Object.create || function create(O, Properties) {
	  var result;

	  if (O !== null) {
	    EmptyConstructor[PROTOTYPE] = anObject(O);
	    result = new EmptyConstructor();
	    EmptyConstructor[PROTOTYPE] = null; // add "__proto__" for Object.getPrototypeOf polyfill

	    result[IE_PROTO] = O;
	  } else result = NullProtoObject();

	  return Properties === undefined ? result : objectDefineProperties(result, Properties);
	};

	// a string of all valid unicode whitespaces
	var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';

	var whitespace = '[' + whitespaces + ']';
	var ltrim = RegExp('^' + whitespace + whitespace + '*');
	var rtrim = RegExp(whitespace + whitespace + '*$'); // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation

	var createMethod = function (TYPE) {
	  return function ($this) {
	    var string = String(requireObjectCoercible($this));
	    if (TYPE & 1) string = string.replace(ltrim, '');
	    if (TYPE & 2) string = string.replace(rtrim, '');
	    return string;
	  };
	};

	var stringTrim = {
	  // `String.prototype.{ trimLeft, trimStart }` methods
	  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
	  start: createMethod(1),
	  // `String.prototype.{ trimRight, trimEnd }` methods
	  // https://tc39.es/ecma262/#sec-string.prototype.trimend
	  end: createMethod(2),
	  // `String.prototype.trim` method
	  // https://tc39.es/ecma262/#sec-string.prototype.trim
	  trim: createMethod(3)
	};

	var getOwnPropertyNames = objectGetOwnPropertyNames.f;
	var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
	var defineProperty = objectDefineProperty.f;
	var trim = stringTrim.trim;
	var NUMBER = 'Number';
	var NativeNumber = global$1[NUMBER];
	var NumberPrototype = NativeNumber.prototype; // Opera ~12 has broken Object#toString

	var BROKEN_CLASSOF = classofRaw(objectCreate(NumberPrototype)) == NUMBER; // `ToNumber` abstract operation
	// https://tc39.es/ecma262/#sec-tonumber

	var toNumber = function (argument) {
	  var it = toPrimitive(argument, false);
	  var first, third, radix, maxCode, digits, length, index, code;

	  if (typeof it == 'string' && it.length > 2) {
	    it = trim(it);
	    first = it.charCodeAt(0);

	    if (first === 43 || first === 45) {
	      third = it.charCodeAt(2);
	      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
	    } else if (first === 48) {
	      switch (it.charCodeAt(1)) {
	        case 66:
	        case 98:
	          radix = 2;
	          maxCode = 49;
	          break;
	        // fast equal of /^0b[01]+$/i

	        case 79:
	        case 111:
	          radix = 8;
	          maxCode = 55;
	          break;
	        // fast equal of /^0o[0-7]+$/i

	        default:
	          return +it;
	      }

	      digits = it.slice(2);
	      length = digits.length;

	      for (index = 0; index < length; index++) {
	        code = digits.charCodeAt(index); // parseInt parses a string to a first unavailable symbol
	        // but ToNumber should return NaN if a string contains unavailable symbols

	        if (code < 48 || code > maxCode) return NaN;
	      }

	      return parseInt(digits, radix);
	    }
	  }

	  return +it;
	}; // `Number` constructor
	// https://tc39.es/ecma262/#sec-number-constructor


	if (isForced_1(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
	  var NumberWrapper = function Number(value) {
	    var it = arguments.length < 1 ? 0 : value;
	    var dummy = this;
	    return dummy instanceof NumberWrapper // check on 1..constructor(foo) case
	    && (BROKEN_CLASSOF ? fails(function () {
	      NumberPrototype.valueOf.call(dummy);
	    }) : classofRaw(dummy) != NUMBER) ? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it);
	  };

	  for (var keys = descriptors ? getOwnPropertyNames(NativeNumber) : ( // ES3:
	  'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + // ES2015 (in case, if modules with ES2015 Number statics required before):
	  'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger,' + // ESNext
	  'fromString,range').split(','), j = 0, key; keys.length > j; j++) {
	    if (has$1(NativeNumber, key = keys[j]) && !has$1(NumberWrapper, key)) {
	      defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key));
	    }
	  }

	  NumberWrapper.prototype = NumberPrototype;
	  NumberPrototype.constructor = NumberWrapper;
	  redefine(global$1, NUMBER, NumberWrapper);
	}

	var toString = Object.prototype.toString;

	var isPlainObj = function (x) {
	  var prototype;
	  return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
	};

	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var propIsEnumerable = Object.propertyIsEnumerable;
	var globalThis$1 = undefined;
	var defaultMergeOpts = {
	  concatArrays: false
	};

	var getEnumerableOwnPropertyKeys = function getEnumerableOwnPropertyKeys(value) {
	  var keys = [];

	  for (var key in value) {
	    if (hasOwnProperty.call(value, key)) {
	      keys.push(key);
	    }
	  }
	  /* istanbul ignore else  */


	  if (Object.getOwnPropertySymbols) {
	    var symbols = Object.getOwnPropertySymbols(value);

	    for (var i = 0; i < symbols.length; i++) {
	      if (propIsEnumerable.call(value, symbols[i])) {
	        keys.push(symbols[i]);
	      }
	    }
	  }

	  return keys;
	};

	function clone(value) {
	  if (Array.isArray(value)) {
	    return cloneArray(value);
	  }

	  if (isPlainObj(value)) {
	    return cloneOptionObject(value);
	  }

	  return value;
	}

	function cloneArray(array) {
	  var result = array.slice(0, 0);
	  getEnumerableOwnPropertyKeys(array).forEach(function (key) {
	    result[key] = clone(array[key]);
	  });
	  return result;
	}

	function cloneOptionObject(obj) {
	  var result = Object.getPrototypeOf(obj) === null ? Object.create(null) : {};
	  getEnumerableOwnPropertyKeys(obj).forEach(function (key) {
	    result[key] = clone(obj[key]);
	  });
	  return result;
	}
	/**
	 * @param merged {already cloned}
	 * @return {cloned Object}
	 */


	var mergeKeys = function mergeKeys(merged, source, keys, mergeOpts) {
	  keys.forEach(function (key) {
	    if (key in merged) {
	      merged[key] = merge(merged[key], source[key], mergeOpts);
	    } else {
	      merged[key] = clone(source[key]);
	    }
	  });
	  return merged;
	};
	/**
	 * @param merged {already cloned}
	 * @return {cloned Object}
	 *
	 * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
	 */


	var concatArrays = function concatArrays(merged, source, mergeOpts) {
	  var result = merged.slice(0, 0);
	  var resultIndex = 0;
	  [merged, source].forEach(function (array) {
	    var indices = []; // `result.concat(array)` with cloning

	    for (var k = 0; k < array.length; k++) {
	      if (!hasOwnProperty.call(array, k)) {
	        continue;
	      }

	      indices.push(String(k));

	      if (array === merged) {
	        // Already cloned
	        result[resultIndex++] = array[k];
	      } else {
	        result[resultIndex++] = clone(array[k]);
	      }
	    } // Merge non-index keys


	    result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(function (key) {
	      return indices.indexOf(key) === -1;
	    }), mergeOpts);
	  });
	  return result;
	};
	/**
	 * @param merged {already cloned}
	 * @return {cloned Object}
	 */


	function merge(merged, source, mergeOpts) {
	  if (mergeOpts.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
	    return concatArrays(merged, source, mergeOpts);
	  }

	  if (!isPlainObj(source) || !isPlainObj(merged)) {
	    return clone(source);
	  }

	  return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), mergeOpts);
	}

	var build = function () {
	  var mergeOpts = merge(clone(defaultMergeOpts), this !== globalThis$1 && this || {}, defaultMergeOpts);
	  var merged = {};

	  for (var i = 0; i < arguments.length; i++) {
	    var option = arguments[i];

	    if (option === undefined) {
	      continue;
	    }

	    if (!isPlainObj(option)) {
	      throw new TypeError('`' + option + '` is not an Option Object');
	    }

	    merged = merge(merged, option, mergeOpts);
	  }

	  return merged;
	};

	var registeringNamespaces = {}; // 注册的命名空间

	function getRegName(iframeSrc, namespace) {
	  return iframeSrc + " " + namespace;
	}
	function getIframe(options, callback) {
	  var iframeId = options.iframeId,
	      iframeSrc = options.iframeSrc;
	  var onload = callback.onload,
	      onerror = callback.onerror;
	  var iframe = document.querySelector("#" + iframeId);

	  if (iframe) {
	    if (iframe.contentWindow) {
	      onload(iframe.contentWindow);
	    } else {
	      onerror('无iframe contentWindow');
	    }
	  } else {
	    iframe = document.createElement('iframe');
	    iframe.id = iframeId;
	    iframe.src = iframeSrc;
	    iframe.style.display = 'none';
	    document.body.appendChild(iframe);

	    iframe.onload = function () {
	      if (iframe && iframe.contentWindow) {
	        onload(iframe.contentWindow);
	      } else {
	        onerror('无iframe contentWindow');
	      }
	    };

	    iframe.onerror = function () {
	      onerror('redux-local-storage用于存储数据的iframe加载失败');
	    };
	  }
	} // 排除指定项

	function handleExcludeItem(exclude, data) {
	  if (Array.isArray(exclude) && exclude.length) {
	    // 排除指定项
	    if (Array.isArray(exclude[0])) {
	      exclude.forEach(function (item) {
	        data = excludeItem(item, data);
	      });
	    } else {
	      data = excludeItem(exclude, data);
	    }
	  }

	  return data;
	}

	function excludeItem(exclude, state) {
	  var newState = JSON.parse(JSON.stringify(state));
	  exclude.reduce(function (obj, item, index) {
	    if (obj[item] !== undefined && index === exclude.length - 1) {
	      delete obj[item];
	      return {};
	    }

	    return obj[item];
	  }, newState);
	  return newState;
	} // 包含指定项


	function handleIncludeItem(include, data) {
	  if (Array.isArray(include) && include.length) {
	    // 包含指定项
	    if (Array.isArray(include[0])) {
	      var stateArray = include.map(function (item) {
	        return includeItem(item, data);
	      });
	      data = stateArray.reduce(function (obj, item) {
	        return build(obj, item);
	      }, {});
	    } else {
	      data = includeItem(include, data);
	    }
	  }

	  return data;
	}

	function includeItem(include, state) {
	  var newState = {};
	  include.reduce(function (_a, item, index) {
	    var newObj = _a[0],
	        oldObj = _a[1];

	    if (oldObj[item] === undefined) {
	      // 没有值 代表无效选项
	      newState = {};
	    } else if (index === include.length - 1) {
	      // 最后一项 可以直接赋值
	      newObj[item] = oldObj[item];
	    } else if (_typeof(oldObj[item]) === 'object' && (oldObj[item].__proto__ === undefined || oldObj[item].__proto__ === Object.prototype)) {
	      // 是正确的对象
	      return [newObj[item] = {}, oldObj[item]];
	    } else {
	      // 其它是无效数据
	      newState = {};
	    }

	    return [{}, {}];
	  }, [newState, state]);
	  return newState;
	}

	function messageBind(_a) {
	  var type = _a.type,
	      regName = _a.regName,
	      timer = _a.timer,
	      dataDispose = _a.dataDispose,
	      exclude = _a.exclude,
	      include = _a.include,
	      resolve = _a.resolve,
	      reject = _a.reject;
	  return function (event) {
	    if (event.data.regName === regName) {
	      // 加载数据
	      if (type === 'getItem') {
	        clearTimeout(Number(timer));

	        if (event.data.type === 'getItemSuccessCallback') {
	          var stateString = event.data.data;

	          if (dataDispose && stateString) {
	            // 处理加密或者其它操作
	            try {
	              stateString = dataDispose(stateString);
	            } catch (err) {
	              stateString = null;
	              reject && reject("load.dataDispose error " + err);
	            }
	          }

	          if (stateString) {
	            // 处理完之后有值 解析后返回即可
	            try {
	              var data = JSON.parse(stateString);
	              data = handleExcludeItem(exclude, data);
	              data = handleIncludeItem(include, data);
	              resolve && resolve(data);
	            } catch (err) {
	              reject && reject("load\u89E3\u6790\u6570\u636E error " + err);
	            }
	          } else {
	            resolve && resolve(undefined);
	          }
	        } else if (event.data.type === 'getItemFailCallback') {
	          reject && reject(event.data.data);
	        }
	      } // 设置数据
	      else if (type === 'setItem') {
	          if (event.data.type === 'setItemSuccessCallback') {
	            resolve && resolve(event.data.data);
	          } else if (event.data.type === 'setItemFailCallback') {
	            reject && reject(event.data.data);
	          }
	        } // 删除数据
	        else if (type === 'removeItem') {
	            if (event.data.type === 'removeItemSuccessCallback') {
	              resolve && resolve();
	            } else if (event.data.type === 'removeItemFailCallback') {
	              reject && reject(event.data.data);
	            }
	          }
	    }
	  };
	}
	var initialOptions = {
	  namespace: 'redux-local-storage',
	  exclude: undefined,
	  include: undefined,
	  shake: undefined,
	  iframeSrc: undefined,
	  iframeId: undefined,
	  timeout: 3000,
	  dataDispose: undefined,
	  onSuccess: undefined,
	  onError: undefined
	};
	function stateDispose(_a) {
	  var store = _a.store,
	      exclude = _a.exclude,
	      include = _a.include,
	      dataDispose = _a.dataDispose,
	      onError = _a.onError;
	  var state = store.getState();
	  state = handleExcludeItem(exclude, state);
	  state = handleIncludeItem(include, state);
	  var stateString = JSON.stringify(state); // 处理存入的信息

	  if (dataDispose) {
	    // 处理加密或者其它操作
	    try {
	      stateString = dataDispose(stateString);
	    } catch (err) {
	      stateString = null;
	      onError && onError("save.dataDispose error " + err);
	    }
	  }

	  return stateString;
	}
	function setLocalStorage(_a) {
	  var stateString = _a.stateString,
	      iframeId = _a.iframeId,
	      iframeSrc = _a.iframeSrc,
	      namespace = _a.namespace,
	      regName = _a.regName,
	      onError = _a.onError,
	      onSuccess = _a.onSuccess;

	  if (iframeId && iframeSrc) {
	    // 如果能存到子文档 扩容需要在不同域
	    getIframe({
	      iframeId: iframeId,
	      iframeSrc: iframeSrc
	    }, {
	      onload: function onload(iframeWindow) {
	        var message = {
	          type: 'setItem',
	          namespace: namespace,
	          regName: regName,
	          data: stateString,
	          origin: window.location.origin
	        };
	        iframeWindow.postMessage(message, iframeSrc); // 发送消息
	      },
	      onerror: function onerror(err) {
	        onError && onError(err);
	      }
	    });
	  } else {
	    // 否则存到当前文档
	    localStorage.setItem(namespace || '', stateString);
	    onSuccess && onSuccess(stateString);
	  }
	}
	function saveLocalStorageMiddleware(options) {
	  if (options === void 0) {
	    options = {};
	  }

	  var _a = options.namespace,
	      namespace = _a === void 0 ? initialOptions.namespace : _a,
	      _b = options.exclude,
	      exclude = _b === void 0 ? initialOptions.exclude : _b,
	      _c = options.include,
	      include = _c === void 0 ? initialOptions.include : _c,
	      _d = options.shake,
	      shake = _d === void 0 ? initialOptions.shake : _d,
	      _e = options.iframeId,
	      iframeId = _e === void 0 ? initialOptions.iframeId : _e,
	      _f = options.iframeSrc,
	      iframeSrc = _f === void 0 ? initialOptions.iframeSrc : _f,
	      _g = options.dataDispose,
	      dataDispose = _g === void 0 ? initialOptions.dataDispose : _g,
	      _h = options.onSuccess,
	      onSuccess = _h === void 0 ? initialOptions.onSuccess : _h,
	      _j = options.onError,
	      onError = _j === void 0 ? initialOptions.onError : _j;
	  var shakeTimer = null; // 延时保存用到的定时器

	  var regName = getRegName(iframeSrc || '', namespace); // 注册名

	  if (registeringNamespaces[regName]) {
	    throw Error('saveLocalStorageMiddleware 在同一地址下，命名空间必须唯一');
	  } else {
	    registeringNamespaces[regName] = {
	      shakeTimer: null
	    };
	  }

	  if (iframeId && iframeSrc) {
	    window.addEventListener('message', messageBind({
	      type: 'setItem',
	      regName: regName,
	      reject: onError,
	      resolve: onSuccess
	    }), false);
	  }

	  return function (store) {
	    return function (next) {
	      return function (action) {
	        next(action);

	        if (typeof shake === 'number' && !isNaN(shake)) {
	          // 需要启用延迟写入clearTimeout(Number(shakeTimer));
	          clearTimeout(Number(shakeTimer));
	          registeringNamespaces[regName].shakeTimer = shakeTimer = setTimeout(function () {
	            registeringNamespaces[regName].shakeTimer = null;
	            var stateString = stateDispose({
	              store: store,
	              exclude: exclude,
	              include: include,
	              dataDispose: dataDispose,
	              onError: onError
	            });
	            stateString && setLocalStorage({
	              stateString: stateString,
	              iframeId: iframeId,
	              iframeSrc: iframeSrc,
	              namespace: namespace,
	              regName: regName,
	              onError: onError,
	              onSuccess: onSuccess
	            });
	          }, shake);
	        } else {
	          var stateString = stateDispose({
	            store: store,
	            exclude: exclude,
	            include: include,
	            dataDispose: dataDispose,
	            onError: onError
	          });
	          stateString && setLocalStorage({
	            stateString: stateString,
	            iframeId: iframeId,
	            iframeSrc: iframeSrc,
	            namespace: namespace,
	            regName: regName,
	            onError: onError,
	            onSuccess: onSuccess
	          });
	        }

	        return action;
	      };
	    };
	  };
	} // 加载默认数据

	function loadLocalStorage(options) {
	  if (options === void 0) {
	    options = {};
	  }

	  var _a = options.namespace,
	      namespace = _a === void 0 ? initialOptions.namespace : _a,
	      _b = options.exclude,
	      exclude = _b === void 0 ? initialOptions.exclude : _b,
	      _c = options.include,
	      include = _c === void 0 ? initialOptions.include : _c,
	      _d = options.iframeSrc,
	      iframeSrc = _d === void 0 ? initialOptions.iframeSrc : _d,
	      _e = options.iframeId,
	      iframeId = _e === void 0 ? initialOptions.iframeId : _e,
	      _f = options.timeout,
	      timeout = _f === void 0 ? initialOptions.timeout : _f,
	      _g = options.dataDispose,
	      dataDispose = _g === void 0 ? initialOptions.dataDispose : _g;
	  return new Promise(function (resolve, reject) {
	    if (iframeId && iframeSrc) {
	      // 使用了内嵌框架 返回promise
	      var timer_1 = null;
	      var regName_1 = getRegName(iframeSrc, namespace); // 注册名

	      window.addEventListener('message', messageBind({
	        type: 'getItem',
	        regName: regName_1,
	        timer: timer_1,
	        dataDispose: dataDispose,
	        reject: reject,
	        resolve: resolve,
	        exclude: exclude,
	        include: include
	      }), false);
	      getIframe({
	        iframeId: iframeId,
	        iframeSrc: iframeSrc
	      }, {
	        onload: function onload(iframeWindow) {
	          timer_1 = setTimeout(function () {
	            reject('timeout');
	          }, timeout);
	          var message = {
	            type: 'getItem',
	            namespace: namespace,
	            regName: regName_1,
	            origin: window.location.origin
	          };
	          iframeWindow.postMessage(message, iframeSrc);
	        },
	        onerror: function onerror(err) {
	          reject(err);
	        }
	      });
	    } else {
	      var stateString = localStorage.getItem(namespace);

	      if (stateString && dataDispose) {
	        // 处理加密或者其它操作
	        try {
	          stateString = dataDispose(stateString);
	        } catch (err) {
	          stateString = null;
	          reject(err);
	        }
	      }

	      if (stateString) {
	        // 数据处理之后解析
	        try {
	          var data = JSON.parse(stateString);
	          data = handleExcludeItem(exclude, data);
	          data = handleIncludeItem(include, data);
	          resolve(data);
	        } catch (err) {
	          reject("load\u89E3\u6790\u6570\u636E error " + err);
	        }
	      } else {
	        resolve(undefined);
	      }
	    }
	  });
	} // 删除数据

	function removeLocalStorage(options) {
	  if (options === void 0) {
	    options = {};
	  }

	  var _a = options.namespace,
	      namespace = _a === void 0 ? initialOptions.namespace : _a,
	      _b = options.iframeId,
	      iframeId = _b === void 0 ? initialOptions.iframeId : _b,
	      _c = options.iframeSrc,
	      iframeSrc = _c === void 0 ? initialOptions.iframeSrc : _c;
	  var regName = getRegName(iframeSrc || '', namespace); // 注册名

	  if (registeringNamespaces[regName] && typeof registeringNamespaces[regName].shakeTimer === 'number') {
	    // 如果开启了定时设置 将直接清除该定时器
	    clearTimeout(Number(registeringNamespaces[regName].shakeTimer));
	    registeringNamespaces[regName].shakeTimer = null;
	  }

	  return new Promise(function (resolve, reject) {
	    if (iframeId && iframeSrc) {
	      window.addEventListener('message', messageBind({
	        type: 'removeItem',
	        regName: regName,
	        resolve: resolve,
	        reject: reject
	      }), false);
	      getIframe({
	        iframeId: iframeId,
	        iframeSrc: iframeSrc
	      }, {
	        onload: function onload(iframeWindow) {
	          var message = {
	            type: 'removeItem',
	            namespace: namespace,
	            regName: regName,
	            origin: window.location.origin
	          };
	          iframeWindow.postMessage(message, iframeSrc);
	        },
	        onerror: function onerror(err) {
	          reject(err);
	        }
	      });
	    } else {
	      localStorage.removeItem(namespace);
	      resolve();
	    }
	  });
	}

	function counter(state, action) {
	  if (state === void 0) {
	    state = {
	      count: 0
	    };
	  }

	  switch (action.type) {
	    case 'INCREMENT':
	      return {
	        count: state.count + 1
	      };

	    case 'DECREMENT':
	      return {
	        count: state.count - 1
	      };

	    default:
	      return state;
	  }
	}

	/**
	 * localStorage储存
	 */

	var capacityNamespace = 'ox'; // 扩容的命名空间

	var capacityDomain = 'http://capacity-ox-spns.duanshenghua.cn'; // 扩容域名

	var capacityIframeId = 'ox-redux-cache'; // 扩容iframe id

	var encKey = 'secret key 123'; // enc加密key
	// 储存中间件

	var localStorageMiddleware = saveLocalStorageMiddleware({
	  namespace: capacityNamespace,
	  shake: 1000,
	  iframeId: capacityIframeId,
	  iframeSrc: capacityDomain,
	  dataDispose: function dataDispose(data) {
	    return aes.encrypt(data, encKey).toString();
	  },
	  // onSuccess(data) {
	  //   console.log('localStorageMiddleware设置成功：', data);
	  // },
	  onError: function onError(err) {
	    console.log('localStorageMiddleware设置失败：', err);
	  }
	}); // 初始化时获取默认值

	var initDataResolve = loadLocalStorage({
	  namespace: capacityNamespace,
	  iframeId: capacityIframeId,
	  iframeSrc: capacityDomain,
	  dataDispose: function dataDispose(data) {
	    return aes.decrypt(data, encKey).toString(encUtf8);
	  }
	}); // 删除存储的值

	function removeRedux() {
	  return removeLocalStorage({
	    namespace: capacityNamespace,
	    iframeSrc: capacityDomain,
	    iframeId: capacityIframeId
	  });
	}

	var middleware = applyMiddleware(localStorageMiddleware);
	var enhancer = compose(middleware); // 获取仓库

	function getStore() {
	  return new Promise(function (resolve) {
	    initDataResolve.then(function (data) {
	      resolve(createStore(counter, data, enhancer));
	    }).catch(function () {
	      resolve(createStore(counter, undefined, enhancer));
	    });
	  });
	}

	function App() {
	  var count = useSelector(function (state) {
	    return state;
	  }).count;
	  var dispatch = useDispatch();
	  return /*#__PURE__*/React__default['default'].createElement("div", null, count, /*#__PURE__*/React__default['default'].createElement("br", null), /*#__PURE__*/React__default['default'].createElement("div", null, /*#__PURE__*/React__default['default'].createElement("button", {
	    onClick: function onClick() {
	      dispatch({
	        type: 'INCREMENT'
	      });
	    }
	  }, "\u6309\u94AE+"), /*#__PURE__*/React__default['default'].createElement("button", {
	    onClick: function onClick() {
	      dispatch({
	        type: 'DECREMENT'
	      });
	    }
	  }, "\u6309\u94AE-"), /*#__PURE__*/React__default['default'].createElement("span", null, "\u70B9\u51FB\u6309\u94AE + - \u4E4B\u540E1\u79D2\uFF0C\u4F1A\u5C06\u6570\u636E\u50A8\u5B58\uFF0C\u5237\u65B0\u4E5F\u4E0D\u4F1A\u4E22\u5931")), /*#__PURE__*/React__default['default'].createElement("button", {
	    onClick: function onClick() {
	      return removeRedux();
	    }
	  }, "remove store"));
	}

	getStore().then(function (store) {
	  ReactDOM__default['default'].render( /*#__PURE__*/React__default['default'].createElement(Provider, {
	    store: store
	  }, /*#__PURE__*/React__default['default'].createElement(App, null)), document.getElementById('app'));
	});

})));
